Snap for 7453540 from 3a33e9de5220f4450e90ea7e6cc66af39428de5e to emu-30-release
Change-Id: I5773c0bcd0ccadf61eb3c9dc61c7565a82431936
diff --git a/BUILD.gn b/BUILD.gn
index f2e28f8..2e204a7 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -2,8 +2,10 @@
sources = [
"android-emu/android/base/AlignedBuf.cpp",
"android-emu/android/base/AlignedBuf.h",
+ "android-emu/android/base/Allocator.h",
"android-emu/android/base/AndroidSubAllocator.cpp",
"android-emu/android/base/AndroidSubAllocator.h",
+ "android-emu/android/base/BumpPool.h",
"android-emu/android/base/Pool.cpp",
"android-emu/android/base/Pool.h",
"android-emu/android/base/Tracing.cpp",
@@ -14,6 +16,13 @@
"android-emu/android/base/files/Stream.h",
"android-emu/android/base/files/StreamSerializing.cpp",
"android-emu/android/base/files/StreamSerializing.h",
+ "android-emu/android/base/fit/Defer.h",
+ "android-emu/android/base/fit/Function.h",
+ "android-emu/android/base/fit/FunctionInternal.h",
+ "android-emu/android/base/fit/Nullable.h",
+ "android-emu/android/base/fit/ThreadChecker.h",
+ "android-emu/android/base/fit/ThreadSafety.h",
+ "android-emu/android/base/fit/UtilityInternal.h",
"android-emu/android/base/ring_buffer.c",
"android-emu/android/base/synchronization/AndroidConditionVariable.h",
"android-emu/android/base/synchronization/AndroidLock.h",
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..c5e9dac
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1,13 @@
+bohu@google.com
+cstout@google.com
+doughorn@google.com
+gurchetansingh@google.com
+kaiyili@google.com
+lfy@google.com
+liyl@google.com
+natsu@google.com
+reveman@google.com
+rkir@google.com
+yahan@google.com
+
+# COMPONENT: Graphics
diff --git a/android-emu/android/base/Allocator.h b/android-emu/android/base/Allocator.h
new file mode 100644
index 0000000..d875de1
--- /dev/null
+++ b/android-emu/android/base/Allocator.h
@@ -0,0 +1,68 @@
+// Copyright 2021 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 <inttypes.h>
+#include <stddef.h>
+#include <string.h>
+
+namespace android {
+namespace base {
+
+// A generic memory allocator interface which could be used to allocate
+// a certain size of memory region, or memory region for arrays / strings.
+// How the memory are recycled / freed is up to derived classes.
+class Allocator {
+public:
+ Allocator() = default;
+ virtual ~Allocator() = default;
+
+ virtual void* alloc(size_t wantedSize) = 0;
+
+ // Convenience function to allocate an array
+ // of objects of type T.
+ template <class T>
+ T* allocArray(size_t count) {
+ size_t bytes = sizeof(T) * count;
+ void* res = alloc(bytes);
+ return (T*)res;
+ }
+
+ char* strDup(const char* toCopy) {
+ size_t bytes = strlen(toCopy) + 1;
+ void* res = alloc(bytes);
+ memset(res, 0x0, bytes);
+ memcpy(res, toCopy, bytes);
+ return (char*)res;
+ }
+
+ char** strDupArray(const char* const* arrayToCopy, size_t count) {
+ char** res = allocArray<char*>(count);
+
+ for (size_t i = 0; i < count; i++) {
+ res[i] = strDup(arrayToCopy[i]);
+ }
+
+ return res;
+ }
+
+ void* dupArray(const void* buf, size_t bytes) {
+ void* res = alloc(bytes);
+ memcpy(res, buf, bytes);
+ return res;
+ }
+};
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/BumpPool.h b/android-emu/android/base/BumpPool.h
index 34dbc7d..545e9e3 100644
--- a/android-emu/android/base/BumpPool.h
+++ b/android-emu/android/base/BumpPool.h
@@ -14,6 +14,7 @@
#pragma once
#include "android/base/AlignedBuf.h"
+#include "android/base/Allocator.h"
#include <vector>
#include <unordered_set>
@@ -28,7 +29,7 @@
// BUT it's necessary to preserve previous pointer values in between the first
// alloc() after a freeAll(), and the freeAll() itself, allowing some sloppy use of
// malloc in the first pass while we find out how much data was needed.
-class BumpPool {
+class BumpPool : public Allocator {
public:
BumpPool(size_t startingBytes = 4096) : mStorage(startingBytes / sizeof(uint64_t)) { }
// All memory allocated by this pool
@@ -36,7 +37,7 @@
// is deconstructed.
~BumpPool() { }
- void* alloc(size_t wantedSize) {
+ void* alloc(size_t wantedSize) override {
size_t wantedSizeRoundedUp =
sizeof(uint64_t) * ((wantedSize + sizeof(uint64_t) - 1) / (sizeof(uint64_t)));
@@ -65,40 +66,6 @@
}
mTotalWantedThisGeneration = 0;
}
-
- // Convenience function to allocate an array
- // of objects of type T.
- template <class T>
- T* allocArray(size_t count) {
- size_t bytes = sizeof(T) * count;
- void* res = alloc(bytes);
- return (T*) res;
- }
-
- char* strDup(const char* toCopy) {
- size_t bytes = strlen(toCopy) + 1;
- void* res = alloc(bytes);
- memset(res, 0x0, bytes);
- memcpy(res, toCopy, bytes);
- return (char*)res;
- }
-
- char** strDupArray(const char* const* arrayToCopy, size_t count) {
- char** res = allocArray<char*>(count);
-
- for (size_t i = 0; i < count; i++) {
- res[i] = strDup(arrayToCopy[i]);
- }
-
- return res;
- }
-
- void* dupArray(const void* buf, size_t bytes) {
- void* res = alloc(bytes);
- memcpy(res, buf, bytes);
- return res;
- }
-
private:
AlignedBuf<uint64_t, 8> mStorage;
std::unordered_set<void*> mFallbackPtrs;
diff --git a/android-emu/android/base/Pool.h b/android-emu/android/base/Pool.h
index b5b1d1b..14a39f8 100644
--- a/android-emu/android/base/Pool.h
+++ b/android-emu/android/base/Pool.h
@@ -13,6 +13,8 @@
// limitations under the License.
#pragma once
+#include "android/base/Allocator.h"
+
#include <unordered_set>
#include <inttypes.h>
@@ -25,7 +27,7 @@
// Class to make it easier to set up memory regions where it is fast
// to allocate/deallocate buffers that have size within
// the specified range.
-class Pool {
+class Pool : public Allocator {
public:
// minSize/maxSize: the target range of sizes for which we want to
// make allocations fast. the greater the range, the more space
@@ -45,45 +47,12 @@
// is deconstructed.
~Pool();
- void* alloc(size_t wantedSize);
+ void* alloc(size_t wantedSize) override;
void free(void* ptr);
// Convenience function to free everything currently allocated.
void freeAll();
- // Convenience function to allocate an array
- // of objects of type T.
- template <class T>
- T* allocArray(size_t count) {
- size_t bytes = sizeof(T) * count;
- void* res = alloc(bytes);
- return (T*) res;
- }
-
- char* strDup(const char* toCopy) {
- size_t bytes = strlen(toCopy) + 1;
- void* res = alloc(bytes);
- memset(res, 0x0, bytes);
- memcpy(res, toCopy, bytes);
- return (char*)res;
- }
-
- char** strDupArray(const char* const* arrayToCopy, size_t count) {
- char** res = allocArray<char*>(count);
-
- for (size_t i = 0; i < count; i++) {
- res[i] = strDup(arrayToCopy[i]);
- }
-
- return res;
- }
-
- void* dupArray(const void* buf, size_t bytes) {
- void* res = alloc(bytes);
- memcpy(res, buf, bytes);
- return res;
- }
-
private:
class Impl;
Impl* mImpl = nullptr;
diff --git a/android-emu/android/base/fit/Defer.h b/android-emu/android/base/fit/Defer.h
new file mode 100644
index 0000000..d120c32
--- /dev/null
+++ b/android-emu/android/base/fit/Defer.h
@@ -0,0 +1,157 @@
+// Copyright 2021 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.
+
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <utility>
+
+#include "Function.h"
+#include "Nullable.h"
+
+namespace android::base {
+namespace fit {
+
+// A move-only deferred action wrapper with RAII semantics.
+// This class is not thread safe.
+//
+// The wrapper holds a function-like callable target with no arguments
+// which it invokes when it goes out of scope unless canceled, called, or
+// moved to a wrapper in a different scope.
+//
+// See |fit::defer()| for idiomatic usage.
+template <typename T>
+class DeferredAction final {
+public:
+ // Creates a deferred action without a pending target.
+ DeferredAction() = default;
+ explicit DeferredAction(decltype(nullptr)) {}
+
+ // Creates a deferred action with a pending target.
+ explicit DeferredAction(T target) : mTarget(std::move(target)) {}
+
+ // Creates a deferred action with a pending target moved from another
+ // deferred action, leaving the other one without a pending target.
+ DeferredAction(DeferredAction&& other) : mTarget(std::move(other.mTarget)) {
+ other.mTarget.reset();
+ }
+
+ // Invokes and releases the deferred action's pending target (if any).
+ ~DeferredAction() { call(); }
+
+ // Returns true if the deferred action has a pending target.
+ explicit operator bool() const { return !!mTarget; }
+
+ // Invokes and releases the deferred action's pending target (if any),
+ // then move-assigns it from another deferred action, leaving the latter
+ // one without a pending target.
+ DeferredAction& operator=(DeferredAction&& other) {
+ if (&other == this)
+ return *this;
+ call();
+ mTarget = std::move(other.mTarget);
+ other.mTarget.reset();
+ return *this;
+ }
+
+ // Invokes and releases the deferred action's pending target (if any).
+ void call() {
+ if (mTarget) {
+ // Move to a local to guard against re-entrance.
+ T local_target = std::move(*mTarget);
+ mTarget.reset();
+ local_target();
+ }
+ }
+
+ // Releases the deferred action's pending target (if any) without
+ // invoking it.
+ void cancel() { mTarget.reset(); }
+ DeferredAction& operator=(decltype(nullptr)) {
+ cancel();
+ return *this;
+ }
+
+ // Assigns a new target to the deferred action.
+ DeferredAction& operator=(T target) {
+ mTarget = std::move(target);
+ return *this;
+ }
+
+ DeferredAction(const DeferredAction& other) = delete;
+ DeferredAction& operator=(const DeferredAction& other) = delete;
+
+private:
+ Nullable<T> mTarget;
+};
+
+template <typename T>
+bool operator==(const DeferredAction<T>& action, decltype(nullptr)) {
+ return !action;
+}
+template <typename T>
+bool operator==(decltype(nullptr), const DeferredAction<T>& action) {
+ return !action;
+}
+template <typename T>
+bool operator!=(const DeferredAction<T>& action, decltype(nullptr)) {
+ return !!action;
+}
+template <typename T>
+bool operator!=(decltype(nullptr), const DeferredAction<T>& action) {
+ return !!action;
+}
+
+// Defers execution of a function-like callable target with no arguments
+// until the value returned by this function goes out of scope unless canceled,
+// called, or moved to a wrapper in a different scope.
+//
+// // This example prints "Hello..." then "Goodbye!".
+// void test() {
+// auto d = fit::defer([]{ puts("Goodbye!"); });
+// puts("Hello...");
+// }
+//
+// // This example prints nothing because the deferred action is canceled.
+// void do_nothing() {
+// auto d = fit::defer([]{ puts("I'm not here."); });
+// d.cancel();
+// }
+//
+// // This example shows how the deferred action can be reassigned assuming
+// // the new target has the same type and the old one, in this case by
+// // representing the target as a |fit::Closure|.
+// void reassign() {
+// auto d = fit::defer<fit::Closure>([] { puts("This runs first."); });
+// d = fit::defer<fit::Closure>([] { puts("This runs afterwards."); });
+// }
+template <typename T>
+inline DeferredAction<T> defer(T target) {
+ return DeferredAction<T>(std::move(target));
+}
+
+// Alias for a deferred_action using a fit::Callback.
+using DeferredCallback = DeferredAction<fit::Callback<void()>>;
+
+// Defers execution of a fit::Callback with no arguments. See |fit::defer| for
+// details.
+inline DeferredCallback deferCallback(fit::Callback<void()> target) {
+ return DeferredCallback(std::move(target));
+}
+
+} // namespace fit
+} // namespace android::base
diff --git a/android-emu/android/base/fit/Function.h b/android-emu/android/base/fit/Function.h
new file mode 100644
index 0000000..4f4b17d
--- /dev/null
+++ b/android-emu/android/base/fit/Function.h
@@ -0,0 +1,513 @@
+// Copyright 2021 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.
+
+// Copyright 2017 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include "FunctionInternal.h"
+#include "UtilityInternal.h"
+
+namespace android::base {
+namespace fit {
+
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+class FunctionImpl;
+
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+class CallbackImpl;
+
+// The default size allowance for storing a target inline within a function
+// object, in bytes. This default allows for inline storage of targets
+// as big as two pointers, such as an object pointer and a pointer to a member
+// function.
+constexpr size_t kDefaultInlineTargetSize = sizeof(void*) * 2;
+
+// A |fit::Function| is a move-only polymorphic function wrapper.
+//
+// If you need a class with similar characteristics that also ensures
+// "run-once" semantics (such as callbacks shared with timeouts, or for
+// service requests with redundant, failover, or fallback service providers),
+// see |fit::Callback|.
+//
+// |fit::Function<T>| behaves like |std::function<T>| except that it is
+// move-only instead of copyable, so it can hold targets that cannot be copied,
+// such as mutable lambdas, and immutable lambdas that capture move-only
+// objects.
+//
+// Targets of up to |inlineTargetSize| bytes in size (rounded up for memory
+// alignment) are stored inline within the function object without incurring
+// any heap allocation. Larger callable objects will be moved to the heap as
+// required.
+//
+// See also |fit::InlineFunction<T, size>| for more control over allocation
+// behavior.
+//
+// SYNOPSIS
+//
+// |T| is the function's signature. e.g. void(int, std::string).
+//
+// |inlineTargetSize| is the minimum size of target that is guaranteed to
+// fit within a function without requiring heap allocation.
+// Defaults to |kDefaultInlineTargetSize|.
+//
+// Class members are documented in |fit::FunctionImpl|, below.
+//
+// EXAMPLES
+//
+// -
+// https://fuchsia.googlesource.com/fuchsia/+/HEAD/sdk/lib/fit/test/examples/function_example1.cc
+// -
+// https://fuchsia.googlesource.com/fuchsia/+/HEAD/sdk/lib/fit/test/examples/function_example2.cc
+//
+template <typename T, size_t inlineTargetSize = kDefaultInlineTargetSize>
+using function = FunctionImpl<inlineTargetSize, /*requireInline=*/false, T>;
+
+// A move-only callable object wrapper that forces callables to be stored inline
+// and never performs heap allocation.
+//
+// Behaves just like |fit::Function<T, inlineTargetSize>| except that
+// attempting to store a target larger than |inlineTargetSize| will fail to
+// compile.
+template <typename T, size_t inlineTargetSize = kDefaultInlineTargetSize>
+using InlineFunction = FunctionImpl<inlineTargetSize,
+ /*requireInline=*/true,
+ T>;
+
+// Synonym for a function which takes no arguments and produces no result.
+using closure = function<void()>;
+
+// A |fit::Callback| is a move-only polymorphic function wrapper that also
+// ensures "run-once" semantics (such as callbacks shared with timeouts, or for
+// service requests with redundant, failover, or fallback service providers).
+// A |fit::Callback| releases it's resources after the first call, and can be
+// inspected before calling, so a potential caller can know if it should call
+// the function, or skip the call because the target was already called.
+//
+// If you need a move-only function class with typical function characteristics,
+// that permits multiple invocations of the same function, see |fit::Function|.
+//
+// |fit::Callback<T>| behaves like |std::function<T>| except:
+//
+// 1. It is move-only instead of copyable, so it can hold targets that cannot
+// be copied, such as mutable lambdas, and immutable lambdas that capture
+// move-only objects.
+// 2. On the first call to invoke a |fit::Callback|, the target function held
+// by the |fit::Callback| cannot be called again.
+//
+// When a |fit::Callback| is invoked for the first time, the target function is
+// released and destructed, along with any resources owned by that function
+// (typically the objects captured by a lambda).
+//
+// A |fit::Callback| in the "already called" state has the same state as a
+// |fit::Callback| that has been assigned to |nullptr|. It can be compared to
+// |nullptr| (via "==" or "!=", and its "operator bool()" returns false, which
+// provides a convenient way to gate whether or not the |fit::Callback| should
+// be called. (Note that invoking an empty |fit::Callback| or |fit::Function|
+// will cause a program abort!)
+//
+// As an example, sharing |fit::Callback| between both a service and a timeout
+// might look something like this:
+//
+// void service_with_timeout(fit::Callback<void(bool)> cb, uint timeout_ms) {
+// service_request([cb = cb.share()]() mutable { if (cb) cb(false); });
+// timeout(timeout_ms, [cb = std::move(cb)]() mutable { if (cb) cb(true); });
+// }
+//
+// Since |fit::Callback| objects are move-only, and not copyable, duplicate
+// references to the same |fit::Callback| can be obtained via share(), as shown
+// in the example above. This method converts the |fit::Callback| into a
+// reference-counted version of the |fit::Callback| and returns a copy of the
+// reference as another |fit::Callback| with the same target function.
+//
+// What is notable about |fit::Callback<T>.share()| is that invoking any shared
+// copy will "nullify" all shared copies, as shown in the example.
+//
+// Note that |fit::Callback| is NOT thread-safe by default. If multi-threaded
+// support is required, you would need to implement your own mutex, or similar
+// guard, before checking and calling a |fit::Callback|.
+//
+// Targets of up to |inlineTargetSize| bytes in size (rounded up for memory
+// alignment) are stored inline within the callback object without incurring
+// any heap allocation. Larger callable objects will be moved to the heap as
+// required.
+//
+// See also |fit::inline_callback<T, size>| for more control over allocation
+// behavior.
+//
+// SYNOPSIS
+//
+// |T| is the callback's signature. e.g. void(int, std::string).
+//
+// |inlineTargetSize| is the minimum size of target that is guaranteed to
+// fit within a callback without requiring heap allocation.
+// Defaults to |kDefaultInlineTargetSize|.
+//
+// Class members are documented in |fit::CallbackImpl|, below.
+//
+template <typename T, size_t inlineTargetSize = kDefaultInlineTargetSize>
+using Callback = CallbackImpl<inlineTargetSize, /*requireInline=*/false, T>;
+
+// A move-only, run-once, callable object wrapper that forces callables to be
+// stored inline and never performs heap allocation.
+//
+// Behaves just like |fit::Callback<T, inlineTargetSize>| except that
+// attempting to store a target larger than |inlineTargetSize| will fail to
+// compile.
+template <typename T, size_t inlineTargetSize = kDefaultInlineTargetSize>
+using InlineCallback = CallbackImpl<inlineTargetSize,
+ /*requireInline=*/true,
+ T>;
+
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+class FunctionImpl<inlineTargetSize, requireInline, Result(Args...)> final
+ : private ::android::base::fit::internal::
+ function_base<inlineTargetSize, requireInline, Result(Args...)> {
+ using Base = ::android::base::fit::internal::
+ function_base<inlineTargetSize, requireInline, Result(Args...)>;
+
+ // function_base requires private access during share()
+ friend class ::android::base::fit::internal::
+ function_base<inlineTargetSize, requireInline, Result(Args...)>;
+
+ // supports target() for shared functions
+ friend const void* ::android::base::fit::internal::get_target_type_id<>(
+ const FunctionImpl<inlineTargetSize, requireInline, Result(Args...)>&);
+
+ template <typename U>
+ using NotSelfType = ::android::base::fit::internal::NotSameType<FunctionImpl, U>;
+
+ template <typename... Conditions>
+ using RequiresConditions = ::android::base::fit::internal::RequiresConditions<Conditions...>;
+
+ template <typename... Conditions>
+ using AssignmentRequiresConditions =
+ ::android::base::fit::internal::AssignmentRequiresConditions<FunctionImpl&, Conditions...>;
+
+public:
+ // The function's result type.
+ using typename Base::result_type;
+
+ // Initializes an empty (null) function. Attempting to call an empty
+ // function will abort the program.
+ FunctionImpl() = default;
+
+ // Creates a function with an empty target (same outcome as the default
+ // constructor).
+ FunctionImpl(decltype(nullptr)) : Base(nullptr) {}
+
+ // Creates a function bound to the specified function pointer.
+ // If target == nullptr, assigns an empty target.
+ FunctionImpl(Result (*target)(Args...)) : Base(target) {}
+
+ // Creates a function bound to the specified callable object.
+ // If target == nullptr, assigns an empty target.
+ //
+ // For functors, we need to capture the raw type but also restrict on the
+ // existence of an appropriate operator () to resolve overloads and implicit
+ // casts properly.
+ //
+ // Note that specializations of this template method that take fit::Callback
+ // objects as the target Callable are deleted (see below).
+ template <typename Callable,
+ RequiresConditions<
+ std::is_convertible<decltype(std::declval<Callable&>()(std::declval<Args>()...)),
+ result_type>,
+ NotSelfType<Callable>> = true>
+ FunctionImpl(Callable&& target) : Base(std::forward<Callable>(target)) {}
+
+ // Deletes the specializations of FunctionImpl(Callable) that would allow
+ // a |fit::Function| to be constructed from a |fit::Callback|. This prevents
+ // unexpected behavior of a |fit::Function| that would otherwise fail after
+ // one call. To explicitly allow this, simply wrap the |fit::Callback| in a
+ // pass-through lambda before passing it to the |fit::Function|.
+ template <size_t otherInlineTargetSize, bool otherRequireInline>
+ FunctionImpl(::android::base::fit::CallbackImpl<otherInlineTargetSize,
+ otherRequireInline,
+ Result(Args...)>) = delete;
+
+ // Creates a function with a target moved from another function,
+ // leaving the other function with an empty target.
+ FunctionImpl(FunctionImpl&& other) : Base(static_cast<Base&&>(other)) {}
+
+ // Destroys the function, releasing its target.
+ ~FunctionImpl() = default;
+
+ // Assigns the function to an empty target. Attempting to invoke the
+ // function will abort the program.
+ FunctionImpl& operator=(decltype(nullptr)) {
+ Base::assign(nullptr);
+ return *this;
+ }
+
+ // Assigns the function to the specified callable object. If target ==
+ // nullptr, assigns an empty target.
+ //
+ // For functors, we need to capture the raw type but also restrict on the
+ // existence of an appropriate operator () to resolve overloads and implicit
+ // casts properly.
+ //
+ // Note that specializations of this template method that take fit::Callback
+ // objects as the target Callable are deleted (see below).
+ template <typename Callable>
+ AssignmentRequiresConditions<
+ std::is_convertible<decltype(std::declval<Callable&>()(std::declval<Args>()...)),
+ result_type>,
+ NotSelfType<Callable>>
+ operator=(Callable&& target) {
+ Base::assign(std::forward<Callable>(target));
+ return *this;
+ }
+
+ // Deletes the specializations of operator=(Callable) that would allow
+ // a |fit::Function| to be assigned from a |fit::Callback|. This
+ // prevents unexpected behavior of a |fit::Function| that would otherwise
+ // fail after one call. To explicitly allow this, simply wrap the
+ // |fit::Callback| in a pass-through lambda before assigning it to the
+ // |fit::Function|.
+ template <size_t otherInlineTargetSize, bool otherRequireInline>
+ FunctionImpl& operator=(::android::base::fit::CallbackImpl<otherInlineTargetSize,
+ otherRequireInline,
+ Result(Args...)>) = delete;
+
+ // Move assignment
+ FunctionImpl& operator=(FunctionImpl&& other) {
+ if (&other == this)
+ return *this;
+ Base::assign(static_cast<Base&&>(other));
+ return *this;
+ }
+
+ // Swaps the functions' targets.
+ void swap(FunctionImpl& other) { Base::swap(other); }
+
+ // Returns a pointer to the function's target.
+ using Base::target;
+
+ // Returns true if the function has a non-empty target.
+ using Base::operator bool;
+
+ // Invokes the function's target.
+ // Aborts if the function's target is empty.
+ Result operator()(Args... args) const { return Base::invoke(std::forward<Args>(args)...); }
+
+ // Returns a new function object that invokes the same target.
+ // The target itself is not copied; it is moved to the heap and its
+ // lifetime is extended until all references have been released.
+ //
+ // Note: This method is not supported on |fit::InlineFunction<>|
+ // because it may incur a heap allocation which is contrary to
+ // the stated purpose of |fit::InlineFunction<>|.
+ FunctionImpl share() {
+ FunctionImpl copy;
+ Base::template share_with<FunctionImpl>(copy);
+ return copy;
+ }
+};
+
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+void swap(FunctionImpl<inlineTargetSize, requireInline, Result, Args...>& a,
+ FunctionImpl<inlineTargetSize, requireInline, Result, Args...>& b) {
+ a.swap(b);
+}
+
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+bool operator==(const FunctionImpl<inlineTargetSize, requireInline, Result, Args...>& f,
+ decltype(nullptr)) {
+ return !f;
+}
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+bool operator==(decltype(nullptr),
+ const FunctionImpl<inlineTargetSize, requireInline, Result, Args...>& f) {
+ return !f;
+}
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+bool operator!=(const FunctionImpl<inlineTargetSize, requireInline, Result, Args...>& f,
+ decltype(nullptr)) {
+ return !!f;
+}
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+bool operator!=(decltype(nullptr),
+ const FunctionImpl<inlineTargetSize, requireInline, Result, Args...>& f) {
+ return !!f;
+}
+
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+class CallbackImpl<inlineTargetSize, requireInline, Result(Args...)> final
+ : private ::android::base::fit::internal::
+ function_base<inlineTargetSize, requireInline, Result(Args...)> {
+ using Base = ::android::base::fit::internal::
+ function_base<inlineTargetSize, requireInline, Result(Args...)>;
+
+ // function_base requires private access during share()
+ friend class ::android::base::fit::internal::
+ function_base<inlineTargetSize, requireInline, Result(Args...)>;
+
+ // supports target() for shared functions
+ friend const void* ::android::base::fit::internal::get_target_type_id<>(
+ const CallbackImpl<inlineTargetSize, requireInline, Result(Args...)>&);
+
+ template <typename U>
+ using NotSelfType = ::android::base::fit::internal::NotSameType<CallbackImpl, U>;
+
+ template <typename... Conditions>
+ using RequiresConditions = ::android::base::fit::internal::RequiresConditions<Conditions...>;
+
+ template <typename... Conditions>
+ using AssignmentRequiresConditions =
+ ::android::base::fit::internal::AssignmentRequiresConditions<CallbackImpl&, Conditions...>;
+
+public:
+ // The callback function's result type.
+ using typename Base::result_type;
+
+ // Initializes an empty (null) callback. Attempting to call an empty
+ // callback will abort the program.
+ CallbackImpl() = default;
+
+ // Creates a callback with an empty target (same outcome as the default
+ // constructor).
+ CallbackImpl(decltype(nullptr)) : Base(nullptr) {}
+
+ // Creates a callback bound to the specified function pointer.
+ // If target == nullptr, assigns an empty target.
+ CallbackImpl(Result (*target)(Args...)) : Base(target) {}
+
+ // Creates a callback bound to the specified callable object.
+ // If target == nullptr, assigns an empty target.
+ //
+ // For functors, we need to capture the raw type but also restrict on the
+ // existence of an appropriate operator () to resolve overloads and implicit
+ // casts properly.
+ template <typename Callable,
+ RequiresConditions<
+ std::is_convertible<decltype(std::declval<Callable&>()(std::declval<Args>()...)),
+ result_type>,
+ NotSelfType<Callable>> = true>
+ CallbackImpl(Callable&& target) : Base(std::forward<Callable>(target)) {}
+
+ // Creates a callback with a target moved from another callback,
+ // leaving the other callback with an empty target.
+ CallbackImpl(CallbackImpl&& other) : Base(static_cast<Base&&>(other)) {}
+
+ // Destroys the callback, releasing its target.
+ ~CallbackImpl() = default;
+
+ // Assigns the callback to an empty target. Attempting to invoke the
+ // callback will abort the program.
+ CallbackImpl& operator=(decltype(nullptr)) {
+ Base::assign(nullptr);
+ return *this;
+ }
+
+ // Assigns the callback to the specified callable object. If target ==
+ // nullptr, assigns an empty target.
+ //
+ // For functors, we need to capture the raw type but also restrict on the
+ // existence of an appropriate operator () to resolve overloads and implicit
+ // casts properly.
+ template <typename Callable>
+ AssignmentRequiresConditions<
+ std::is_convertible<decltype(std::declval<Callable&>()(std::declval<Args>()...)),
+ result_type>,
+ NotSelfType<Callable>>
+ operator=(Callable&& target) {
+ Base::assign(std::forward<Callable>(target));
+ return *this;
+ }
+
+ // Move assignment
+ CallbackImpl& operator=(CallbackImpl&& other) {
+ if (&other == this)
+ return *this;
+ Base::assign(static_cast<Base&&>(other));
+ return *this;
+ }
+
+ // Swaps the callbacks' targets.
+ void swap(CallbackImpl& other) { Base::swap(other); }
+
+ // Returns a pointer to the callback's target.
+ using Base::target;
+
+ // Returns true if the callback has a non-empty target.
+ using Base::operator bool;
+
+ // Invokes the callback's target.
+ // Aborts if the callback's target is empty.
+ // |fit::Callback| must be non-const to invoke. Before the target function
+ // is actually called, the fit::Callback will be set to the default empty
+ // state (== nullptr, and operator bool() will subsequently return |false|).
+ // The target function will then be released after the function is called.
+ // If the callback was shared, any remaining copies will also be cleared.
+ Result operator()(Args... args) {
+ auto temp = std::move(*this);
+ return temp.invoke(std::forward<Args>(args)...);
+ }
+
+ // Returns a new callback object that invokes the same target.
+ // The target itself is not copied; it is moved to the heap and its
+ // lifetime is extended until all references have been released.
+ // For |fit::Callback| (unlike fit::Function), the first invocation of the
+ // callback will release all references to the target. All callbacks
+ // derived from the same original callback (via share()) will be cleared,
+ // as if set to |nullptr|, and "operator bool()" will return false.
+ //
+ // Note: This method is not supported on |fit::InlineFunction<>|
+ // because it may incur a heap allocation which is contrary to
+ // the stated purpose of |fit::InlineFunction<>|.
+ CallbackImpl share() {
+ CallbackImpl copy;
+ Base::template share_with<CallbackImpl>(copy);
+ return copy;
+ }
+};
+
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+void swap(CallbackImpl<inlineTargetSize, requireInline, Result, Args...>& a,
+ CallbackImpl<inlineTargetSize, requireInline, Result, Args...>& b) {
+ a.swap(b);
+}
+
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+bool operator==(const CallbackImpl<inlineTargetSize, requireInline, Result, Args...>& f,
+ decltype(nullptr)) {
+ return !f;
+}
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+bool operator==(decltype(nullptr),
+ const CallbackImpl<inlineTargetSize, requireInline, Result, Args...>& f) {
+ return !f;
+}
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+bool operator!=(const CallbackImpl<inlineTargetSize, requireInline, Result, Args...>& f,
+ decltype(nullptr)) {
+ return !!f;
+}
+template <size_t inlineTargetSize, bool requireInline, typename Result, typename... Args>
+bool operator!=(decltype(nullptr),
+ const CallbackImpl<inlineTargetSize, requireInline, Result, Args...>& f) {
+ return !!f;
+}
+
+// Returns a Callable object that invokes a member function of an object.
+template <typename R, typename T, typename... Args>
+auto bindMember(T* instance, R (T::*fn)(Args...)) {
+ return [instance, fn](Args... args) { return (instance->*fn)(std::forward<Args>(args)...); };
+}
+
+} // namespace fit
+} // namespace android::base
diff --git a/android-emu/android/base/fit/FunctionInternal.h b/android-emu/android/base/fit/FunctionInternal.h
new file mode 100644
index 0000000..3fb1ac5
--- /dev/null
+++ b/android-emu/android/base/fit/FunctionInternal.h
@@ -0,0 +1,456 @@
+// Copyright 2021 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.
+
+// Copyright 2017 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#include <memory>
+
+#include "Nullable.h"
+
+#include <new>
+#include <type_traits>
+#include <utility>
+
+namespace android::base {
+namespace fit {
+namespace internal {
+
+template <typename Result, typename... Args>
+struct target_ops final {
+ const void* (*target_type_id)(void* bits, const void* impl_ops);
+ void* (*get)(void* bits);
+ Result (*invoke)(void* bits, Args... args);
+ void (*move)(void* from_bits, void* to_bits);
+ void (*destroy)(void* bits);
+};
+
+template <typename Callable, bool is_inline, bool is_shared, typename Result, typename... Args>
+struct target;
+
+inline const void* unshared_target_type_id(void* bits, const void* impl_ops) {
+ return impl_ops;
+}
+
+// vtable for nullptr (empty target function)
+
+template <typename Result, typename... Args>
+struct target<decltype(nullptr),
+ /*is_inline=*/true,
+ /*is_shared=*/false,
+ Result,
+ Args...>
+ final {
+ static Result invoke(void* bits, Args... args) { __builtin_abort(); }
+
+ static const target_ops<Result, Args...> ops;
+};
+
+inline void* null_target_get(void* bits) {
+ return nullptr;
+}
+inline void null_target_move(void* from_bits, void* to_bits) {}
+inline void null_target_destroy(void* bits) {}
+
+template <typename Result, typename... Args>
+constexpr target_ops<Result, Args...> target<decltype(nullptr),
+ /*is_inline=*/true,
+ /*is_shared=*/false,
+ Result,
+ Args...>::ops = {
+ &unshared_target_type_id, &null_target_get, &target::invoke, &null_target_move,
+ &null_target_destroy};
+
+// vtable for inline target function
+
+template <typename Callable, typename Result, typename... Args>
+struct target<Callable,
+ /*is_inline=*/true,
+ /*is_shared=*/false,
+ Result,
+ Args...>
+ final {
+ template <typename Callable_>
+ static void initialize(void* bits, Callable_&& target) {
+ new (bits) Callable(std::forward<Callable_>(target));
+ }
+ static Result invoke(void* bits, Args... args) {
+ auto& target = *static_cast<Callable*>(bits);
+ return target(std::forward<Args>(args)...);
+ }
+ static void move(void* from_bits, void* to_bits) {
+ auto& from_target = *static_cast<Callable*>(from_bits);
+ new (to_bits) Callable(std::move(from_target));
+ from_target.~Callable();
+ }
+ static void destroy(void* bits) {
+ auto& target = *static_cast<Callable*>(bits);
+ target.~Callable();
+ }
+
+ static const target_ops<Result, Args...> ops;
+};
+
+inline void* inline_target_get(void* bits) {
+ return bits;
+}
+
+template <typename Callable, typename Result, typename... Args>
+constexpr target_ops<Result, Args...> target<Callable,
+ /*is_inline=*/true,
+ /*is_shared=*/false,
+ Result,
+ Args...>::ops = {
+ &unshared_target_type_id, &inline_target_get, &target::invoke, &target::move, &target::destroy};
+
+// vtable for pointer to target function
+
+template <typename Callable, typename Result, typename... Args>
+struct target<Callable,
+ /*is_inline=*/false,
+ /*is_shared=*/false,
+ Result,
+ Args...>
+ final {
+ template <typename Callable_>
+ static void initialize(void* bits, Callable_&& target) {
+ auto ptr = static_cast<Callable**>(bits);
+ *ptr = new Callable(std::forward<Callable_>(target));
+ }
+ static Result invoke(void* bits, Args... args) {
+ auto& target = **static_cast<Callable**>(bits);
+ return target(std::forward<Args>(args)...);
+ }
+ static void move(void* from_bits, void* to_bits) {
+ auto from_ptr = static_cast<Callable**>(from_bits);
+ auto to_ptr = static_cast<Callable**>(to_bits);
+ *to_ptr = *from_ptr;
+ }
+ static void destroy(void* bits) {
+ auto ptr = static_cast<Callable**>(bits);
+ delete *ptr;
+ }
+
+ static const target_ops<Result, Args...> ops;
+};
+
+inline void* heap_target_get(void* bits) {
+ return *static_cast<void**>(bits);
+}
+
+template <typename Callable, typename Result, typename... Args>
+constexpr target_ops<Result, Args...> target<Callable,
+ /*is_inline=*/false,
+ /*is_shared=*/false,
+ Result,
+ Args...>::ops = {
+ &unshared_target_type_id, &heap_target_get, &target::invoke, &target::move, &target::destroy};
+
+// vtable for fit::function std::shared_ptr to target function
+
+template <typename SharedFunction>
+const void* get_target_type_id(const SharedFunction& function_or_callback) {
+ return function_or_callback.target_type_id();
+}
+
+// For this vtable,
+// Callable by definition will be either a fit::function or fit::callback
+template <typename SharedFunction, typename Result, typename... Args>
+struct target<SharedFunction,
+ /*is_inline=*/false,
+ /*is_shared=*/true,
+ Result,
+ Args...>
+ final {
+ static void initialize(void* bits, SharedFunction target) {
+ new (bits) std::shared_ptr<SharedFunction>(
+ std::move(std::make_shared<SharedFunction>(std::move(target))));
+ }
+ static void copy_shared_ptr(void* from_bits, void* to_bits) {
+ auto& from_shared_ptr = *static_cast<std::shared_ptr<SharedFunction>*>(from_bits);
+ new (to_bits) std::shared_ptr<SharedFunction>(from_shared_ptr);
+ }
+ static const void* target_type_id(void* bits, const void* impl_ops) {
+ auto& function_or_callback = **static_cast<std::shared_ptr<SharedFunction>*>(bits);
+ return ::android::base::fit::internal::get_target_type_id(function_or_callback);
+ }
+ static void* get(void* bits) {
+ auto& function_or_callback = **static_cast<std::shared_ptr<SharedFunction>*>(bits);
+ return function_or_callback.template target<SharedFunction>(
+ /*check=*/false); // void* will fail the check
+ }
+ static Result invoke(void* bits, Args... args) {
+ auto& function_or_callback = **static_cast<std::shared_ptr<SharedFunction>*>(bits);
+ return function_or_callback(std::forward<Args>(args)...);
+ }
+ static void move(void* from_bits, void* to_bits) {
+ auto from_shared_ptr = std::move(*static_cast<std::shared_ptr<SharedFunction>*>(from_bits));
+ new (to_bits) std::shared_ptr<SharedFunction>(std::move(from_shared_ptr));
+ }
+ static void destroy(void* bits) {
+ static_cast<std::shared_ptr<SharedFunction>*>(bits)->reset();
+ }
+
+ static const target_ops<Result, Args...> ops;
+};
+
+template <typename SharedFunction, typename Result, typename... Args>
+constexpr target_ops<Result, Args...> target<SharedFunction,
+ /*is_inline=*/false,
+ /*is_shared=*/true,
+ Result,
+ Args...>::ops = {
+ &target::target_type_id, &target::get, &target::invoke, &target::move, &target::destroy};
+
+template <size_t inline_target_size, bool requireInline, typename Result, typename... Args>
+class function_base;
+
+// Function implementation details.
+// See |fit::function| and |fit::callback| documentation for more information.
+template <size_t inline_target_size, bool requireInline, typename Result, typename... Args>
+class function_base<inline_target_size, requireInline, Result(Args...)> {
+ using ops_type = const target_ops<Result, Args...>*;
+ using storage_type = typename std::aligned_storage<(
+ inline_target_size >= sizeof(void*) ? inline_target_size : sizeof(void*))>::
+ type; // avoid including <algorithm> for max
+ template <typename Callable>
+ using target_type = target<Callable,
+ (sizeof(Callable) <= sizeof(storage_type)),
+ /*is_shared=*/false,
+ Result,
+ Args...>;
+ template <typename SharedFunction>
+ using shared_target_type = target<SharedFunction,
+ /*is_inline=*/false,
+ /*is_shared=*/true,
+ Result,
+ Args...>;
+ using null_target_type = target_type<decltype(nullptr)>;
+
+protected:
+ using result_type = Result;
+
+ function_base() { initialize_null_target(); }
+
+ function_base(decltype(nullptr)) { initialize_null_target(); }
+
+ function_base(Result (*target)(Args...)) { initialize_target(target); }
+
+ template <typename Callable,
+ typename = std::enable_if_t<
+ std::is_convertible<decltype(std::declval<Callable&>()(std::declval<Args>()...)),
+ result_type>::value>>
+ function_base(Callable&& target) {
+ initialize_target(std::forward<Callable>(target));
+ }
+
+ function_base(function_base&& other) { move_target_from(std::move(other)); }
+
+ ~function_base() { destroy_target(); }
+
+ // Returns true if the function has a non-empty target.
+ explicit operator bool() const { return ops_->get(&bits_) != nullptr; }
+
+ // Returns a pointer to the function's target.
+ // If |check| is true (the default), the function _may_ abort if the
+ // caller tries to assign the target to a varible of the wrong type. (This
+ // check is currently skipped for share()d objects.)
+ // Note the shared pointer vtable must set |check| to false to assign the
+ // target to |void*|.
+ template <typename Callable>
+ Callable* target(bool check = true) {
+ if (check)
+ check_target_type<Callable>();
+ return static_cast<Callable*>(ops_->get(&bits_));
+ }
+
+ // Returns a pointer to the function's target (const version).
+ // If |check| is true (the default), the function _may_ abort if the
+ // caller tries to assign the target to a varible of the wrong type. (This
+ // check is currently skipped for share()d objects.)
+ // Note the shared pointer vtable must set |check| to false to assign the
+ // target to |void*|.
+ template <typename Callable>
+ const Callable* target(bool check = true) const {
+ if (check)
+ check_target_type<Callable>();
+ return static_cast<Callable*>(ops_->get(&bits_));
+ }
+
+ // Used by the derived "impl" classes to implement share().
+ //
+ // The caller creates a new object of the same type as itself, and passes in
+ // the empty object. This function first checks if |this| is already shared,
+ // and if not, creates a new version of itself containing a
+ // |std::shared_ptr| to its original self, and updates |ops_| to the vtable
+ // for the shared version.
+ //
+ // Then it copies its |shared_ptr| to the |bits_| of the given |copy|,
+ // and assigns the same shared pointer vtable to the copy's |ops_|.
+ //
+ // The target itself is not copied; it is moved to the heap and its
+ // lifetime is extended until all references have been released.
+ //
+ // Note: This method is not supported on |fit::InlineFunction<>|
+ // because it may incur a heap allocation which is contrary to
+ // the stated purpose of |fit::InlineFunction<>|.
+ template <typename SharedFunction>
+ void share_with(SharedFunction& copy) {
+ static_assert(!requireInline, "Inline functions cannot be shared.");
+ if (ops_->get(&bits_) != nullptr) {
+ if (ops_ != &shared_target_type<SharedFunction>::ops) {
+ convert_to_shared_target<SharedFunction>();
+ }
+ copy_shared_target_to(copy);
+ }
+ }
+
+ // Used by derived "impl" classes to implement operator()().
+ // Invokes the function's target.
+ // Note that fit::callback will release the target immediately after
+ // invoke() (also affecting any share()d copies).
+ // Aborts if the function's target is empty.
+ Result invoke(Args... args) const { return ops_->invoke(&bits_, std::forward<Args>(args)...); }
+
+ // Used by derived "impl" classes to implement operator=().
+ // Assigns an empty target.
+ void assign(decltype(nullptr)) {
+ destroy_target();
+ initialize_null_target();
+ }
+
+ // Used by derived "impl" classes to implement operator=().
+ // Assigns the function's target.
+ // If target == nullptr, assigns an empty target.
+ template <typename Callable,
+ typename = std::enable_if_t<
+ std::is_convertible<decltype(std::declval<Callable&>()(std::declval<Args>()...)),
+ result_type>::value>>
+ void assign(Callable&& target) {
+ destroy_target();
+ initialize_target(std::forward<Callable>(target));
+ }
+
+ // Used by derived "impl" classes to implement operator=().
+ // Assigns the function with a target moved from another function,
+ // leaving the other function with an empty target.
+ void assign(function_base&& other) {
+ destroy_target();
+ move_target_from(std::move(other));
+ }
+
+ void swap(function_base& other) {
+ if (&other == this)
+ return;
+ ops_type temp_ops = ops_;
+ storage_type temp_bits;
+ ops_->move(&bits_, &temp_bits);
+
+ ops_ = other.ops_;
+ other.ops_->move(&other.bits_, &bits_);
+
+ other.ops_ = temp_ops;
+ temp_ops->move(&temp_bits, &other.bits_);
+ }
+
+ // returns an opaque ID unique to the |Callable| type of the target.
+ // Used by check_target_type.
+ const void* target_type_id() const { return ops_->target_type_id(&bits_, ops_); }
+
+ // Deleted copy constructor and assign. |function_base| implementations are
+ // move-only.
+ function_base(const function_base& other) = delete;
+ function_base& operator=(const function_base& other) = delete;
+
+ // Move assignment must be provided by subclasses.
+ function_base& operator=(function_base&& other) = delete;
+
+private:
+ // Implements the move operation, used by move construction and move
+ // assignment. Leaves other target initialized to null.
+ void move_target_from(function_base&& other) {
+ ops_ = other.ops_;
+ other.ops_->move(&other.bits_, &bits_);
+ other.initialize_null_target();
+ }
+
+ // fit::function and fit::callback are not directly copyable, but share()
+ // will create shared references to the original object. This method
+ // implements the copy operation for the |std::shared_ptr| wrapper.
+ template <typename SharedFunction>
+ void copy_shared_target_to(SharedFunction& copy) {
+ copy.destroy_target();
+ assert(ops_ == &shared_target_type<SharedFunction>::ops);
+ shared_target_type<SharedFunction>::copy_shared_ptr(&bits_, ©.bits_);
+ copy.ops_ = ops_;
+ }
+
+ // assumes target is uninitialized
+ void initialize_null_target() { ops_ = &null_target_type::ops; }
+
+ // target may or may not be initialized.
+ template <typename Callable>
+ void initialize_target(Callable&& target) {
+ // Convert function or function references to function pointer.
+ using DecayedCallable = std::decay_t<Callable>;
+ static_assert(
+ std::alignment_of<DecayedCallable>::value <= std::alignment_of<storage_type>::value,
+ "Alignment of Callable must be <= alignment of max_align_t.");
+ static_assert(!requireInline || sizeof(DecayedCallable) <= inline_target_size,
+ "Callable too large to store inline as requested.");
+ if (is_null(target)) {
+ initialize_null_target();
+ } else {
+ ops_ = &target_type<DecayedCallable>::ops;
+ target_type<DecayedCallable>::initialize(&bits_, std::forward<Callable>(target));
+ }
+ }
+
+ // assumes target is uninitialized
+ template <typename SharedFunction>
+ void convert_to_shared_target() {
+ shared_target_type<SharedFunction>::initialize(
+ &bits_, std::move(*static_cast<SharedFunction*>(this)));
+ ops_ = &shared_target_type<SharedFunction>::ops;
+ }
+
+ // leaves target uninitialized
+ void destroy_target() { ops_->destroy(&bits_); }
+
+ // Called by target() if |check| is true.
+ // Checks the template parameter, usually inferred from the context of
+ // the call to target(), and aborts the program if it can determine that
+ // the Callable type is not compatible with the function's Result and Args.
+ template <typename Callable>
+ void check_target_type() const {
+ if (target_type<Callable>::ops.target_type_id(nullptr, &target_type<Callable>::ops) !=
+ target_type_id()) {
+ __builtin_abort();
+ }
+ }
+
+ ops_type ops_;
+ mutable storage_type bits_;
+};
+
+} // namespace internal
+
+} // namespace fit
+} // namespace android::base
diff --git a/android-emu/android/base/fit/Nullable.h b/android-emu/android/base/fit/Nullable.h
new file mode 100644
index 0000000..e05021b
--- /dev/null
+++ b/android-emu/android/base/fit/Nullable.h
@@ -0,0 +1,265 @@
+// Copyright 2021 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.
+
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <assert.h>
+
+#include <optional>
+#include <type_traits>
+#include <utility>
+
+namespace android::base {
+namespace fit {
+
+// Determines whether a type can be compared with nullptr.
+template <typename T, typename Comparable = bool>
+struct IsComparableWithNull : public std::false_type {};
+template <typename T>
+struct IsComparableWithNull<T, decltype(std::declval<const T&>() == nullptr)>
+ : public std::true_type {};
+
+// Suppress the warning when the compiler can see that a nullable value is
+// never equal to nullptr.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waddress"
+template <typename T, std::enable_if_t<IsComparableWithNull<T>::value, bool> = true>
+constexpr inline bool isNull(T&& value) {
+ return std::forward<T>(value) == nullptr;
+}
+#pragma GCC diagnostic pop
+
+template <typename T, std::enable_if_t<!IsComparableWithNull<T>::value, bool> = false>
+constexpr inline bool isNull(T&&) {
+ return false;
+}
+
+// Determines whether a type can be initialized, assigned, and compared
+// with nullptr.
+template <typename T>
+struct IsNullable
+ : public std::integral_constant<bool,
+ std::is_constructible<T, decltype(nullptr)>::value &&
+ std::is_assignable<T&, decltype(nullptr)>::value &&
+ IsComparableWithNull<T>::value> {};
+template <>
+struct IsNullable<void> : public std::false_type {};
+
+// Holds a value or nullptr.
+//
+// This class is similar to |std::optional<T>| except that it uses less
+// storage when the value type can be initialized, assigned, and compared
+// with nullptr.
+//
+// For example:
+// - sizeof(fit::nullable<void*>) == sizeof(void*)
+// - sizeof(std::optional<void*>) == sizeof(struct { bool; void*; })
+// - sizeof(fit::nullable<int>) == sizeof(struct { bool; int; })
+// - sizeof(std::optional<int>) == sizeof(struct { bool; int; })
+//
+// TODO(fxbug.dev/4681): fit::nullable does not precisely mirror
+// std::optional. This should be corrected to avoid surprises when switching
+// between the types.
+template <typename T,
+ bool = (IsNullable<T>::value && std::is_constructible<T, T&&>::value &&
+ std::is_assignable<T&, T&&>::value)>
+class Nullable final {
+public:
+ using value_type = T;
+
+ ~Nullable() = default;
+ constexpr Nullable() = default;
+
+ explicit constexpr Nullable(decltype(nullptr)) {}
+ explicit constexpr Nullable(T value) : mOpt(std::move(value)) {}
+
+ constexpr Nullable(const Nullable& other) = default;
+ constexpr Nullable& operator=(const Nullable& other) = default;
+
+ constexpr Nullable(Nullable&& other) = default;
+ constexpr Nullable& operator=(Nullable&& other) = default;
+
+ constexpr T& value() & { return mOpt.value(); }
+ constexpr const T& value() const& { return mOpt.value(); }
+ constexpr T&& value() && { return std::move(mOpt.value()); }
+ constexpr const T&& value() const&& { return std::move(mOpt.value()); }
+
+ template <typename U = T>
+ constexpr T valueOr(U&& default_value) const {
+ return mOpt.value_or(std::forward<U>(default_value));
+ }
+
+ constexpr T* operator->() { return &*mOpt; }
+ constexpr const T* operator->() const { return &*mOpt; }
+ constexpr T& operator*() { return *mOpt; }
+ constexpr const T& operator*() const { return *mOpt; }
+
+ constexpr bool hasValue() const { return mOpt.has_value(); }
+ explicit constexpr operator bool() const { return hasValue(); }
+
+ constexpr Nullable& operator=(decltype(nullptr)) {
+ reset();
+ return *this;
+ }
+
+ constexpr Nullable& operator=(T value) {
+ mOpt = std::move(value);
+ return *this;
+ }
+
+ constexpr void reset() { mOpt.reset(); }
+
+ constexpr void swap(Nullable& other) { mOpt.swap(other.mOpt); }
+
+private:
+ std::optional<T> mOpt;
+};
+
+template <typename T>
+class Nullable<T, true> final {
+public:
+ using value_type = T;
+
+ constexpr Nullable() : mValue(nullptr) {}
+ explicit constexpr Nullable(decltype(nullptr)) : mValue(nullptr) {}
+ explicit constexpr Nullable(T value) : mValue(std::move(value)) {}
+ constexpr Nullable(const Nullable& other) = default;
+ constexpr Nullable(Nullable&& other) : mValue(std::move(other.value_)) {}
+ ~Nullable() = default;
+
+ constexpr T& value() & {
+ if (hasValue()) {
+ return mValue;
+ } else {
+ __builtin_abort();
+ }
+ }
+ constexpr const T& value() const& {
+ if (hasValue()) {
+ return mValue;
+ } else {
+ __builtin_abort();
+ }
+ }
+ constexpr T&& value() && {
+ if (hasValue()) {
+ return std::move(mValue);
+ } else {
+ __builtin_abort();
+ }
+ }
+ constexpr const T&& value() const&& {
+ if (hasValue()) {
+ return std::move(mValue);
+ } else {
+ __builtin_abort();
+ }
+ }
+
+ template <typename U = T>
+ constexpr T valueOr(U&& default_value) const {
+ return hasValue() ? mValue : static_cast<T>(std::forward<U>(default_value));
+ }
+
+ constexpr T* operator->() { return &mValue; }
+ constexpr const T* operator->() const { return &mValue; }
+ constexpr T& operator*() { return mValue; }
+ constexpr const T& operator*() const { return mValue; }
+
+ constexpr bool hasValue() const { return !(mValue == nullptr); }
+ explicit constexpr operator bool() const { return hasValue(); }
+
+ constexpr Nullable& operator=(const Nullable& other) = default;
+ constexpr Nullable& operator=(Nullable&& other) {
+ mValue = std::move(other.value_);
+ return *this;
+ }
+
+ constexpr Nullable& operator=(decltype(nullptr)) {
+ reset();
+ return *this;
+ }
+
+ constexpr Nullable& operator=(T value) {
+ mValue = std::move(value);
+ return *this;
+ }
+
+ constexpr void reset() { mValue = nullptr; }
+
+ constexpr void swap(Nullable& other) {
+ using std::swap;
+ swap(mValue, other.value_);
+ }
+
+private:
+ T mValue;
+};
+
+template <typename T>
+void swap(Nullable<T>& a, Nullable<T>& b) {
+ a.swap(b);
+}
+
+template <typename T>
+constexpr bool operator==(const Nullable<T>& lhs, decltype(nullptr)) {
+ return !lhs.hasValue();
+}
+template <typename T>
+constexpr bool operator!=(const Nullable<T>& lhs, decltype(nullptr)) {
+ return lhs.hasValue();
+}
+
+template <typename T>
+constexpr bool operator==(decltype(nullptr), const Nullable<T>& rhs) {
+ return !rhs.hasValue();
+}
+template <typename T>
+constexpr bool operator!=(decltype(nullptr), const Nullable<T>& rhs) {
+ return rhs.hasValue();
+}
+
+template <typename T, typename U>
+constexpr bool operator==(const Nullable<T>& lhs, const Nullable<U>& rhs) {
+ return (lhs.hasValue() == rhs.hasValue()) && (!lhs.hasValue() || *lhs == *rhs);
+}
+template <typename T, typename U>
+constexpr bool operator!=(const Nullable<T>& lhs, const Nullable<U>& rhs) {
+ return (lhs.hasValue() != rhs.hasValue()) || (lhs.hasValue() && *lhs != *rhs);
+}
+
+template <typename T, typename U>
+constexpr bool operator==(const Nullable<T>& lhs, const U& rhs) {
+ return (lhs.hasValue() != isNull(rhs)) && (!lhs.hasValue() || *lhs == rhs);
+}
+template <typename T, typename U>
+constexpr bool operator!=(const Nullable<T>& lhs, const U& rhs) {
+ return (lhs.hasValue() == isNull(rhs)) || (lhs.hasValue() && *lhs != rhs);
+}
+
+template <typename T, typename U>
+constexpr bool operator==(const T& lhs, const Nullable<U>& rhs) {
+ return (isNull(lhs) != rhs.hasValue()) && (!rhs.hasValue() || lhs == *rhs);
+}
+template <typename T, typename U>
+constexpr bool operator!=(const T& lhs, const Nullable<U>& rhs) {
+ return (isNull(lhs) == rhs.hasValue()) || (rhs.hasValue() && lhs != *rhs);
+}
+
+} // namespace fit
+} // namespace android::base
diff --git a/android-emu/android/base/fit/README b/android-emu/android/base/fit/README
new file mode 100644
index 0000000..4b3eeeb
--- /dev/null
+++ b/android-emu/android/base/fit/README
@@ -0,0 +1,150 @@
+libfit
+
+Source: https://fuchsia.googlesource.com/fuchsia/+/main/sdk/lib/fit/
+Version: 36303cd2d1611cb1b670235692d01a92e83ecd21
+License:
+
+Copyright 2019 The Fuchsia Authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+======
+
+FIT is a lean library of portable C++ abstractions for control flow and
+memory management beyond what is offered by the C++ 17 standard library.
+
+FIT only depends on the C++ language and standard library, including some C++17
+library features. It offers essential enhancements to the C++ standard library
+rather than attempting to replace it or become a framework for writing
+applications. FIT can be thought of as an "annex" that expresses a few ideas
+we wish the C++ standard library might itself implement someday.
+
+FIT is lean.
+
+## What Belongs in FIT
+
+Several Fuchsia SDK libraries, such as *libfidl*, depend on FIT and on the C++
+standard library. As these libraries are broadly used, we must take care in
+deciding what features to include in FIT to avoid burdening developers with
+unnecessary code or dependencies.
+
+In general, the goal is to identify specific abstractions that make sense to
+generalize across the entire ecosystem of Fuchsia C++ applications. These will
+necessarily be somewhat low-level but high impact. We don't want to add code to
+FIT simply because we think it's cool. We need evidence that it is a common
+idiom and that a broad audience of developers will significantly benefit from
+its promotion.
+
+Here are a few criteria to consider:
+
+- Is the feature lightweight, general-purpose, and platform-independent?
+- Is the feature not well served by other means, particularly by the C++
+ standard library?
+- Is the feature needed by a Fuchsia SDK library?
+- Does the feature embody a beneficial idiom that clients of the Fuchsia SDK
+ commonly use?
+- Has the feature been re-implemented many times already leading to code
+ fragmentation that we would like to eliminate?
+
+If in doubt, leave it out. See [Justifications] below.
+
+## What Doesn't Belong in FIT
+
+FIT is not intended to become a catch-all class library.
+
+Specifically prohibited features:
+
+- Features that introduce dependencies on libraries other than the C and C++
+ standard library.
+- Features that only work on certain operating systems.
+- Collection classes where the C++ 17 standard library already offers an
+ adequate (if not perfect) alternative.
+- Classes that impose an implementation burden on clients such as event loops,
+ dispatchers, frameworks, and other glue code.
+
+## Implementation Considerations
+
+FIT is not exception safe (but could be made to be in the future).
+
+## Style Conventions
+
+The API style was modified to fit current android::base library conventions.
+
+In brief:
+
+- Class identifiers are CamelCase
+- Class methods and variable identifiers use "camelCase", class fields use
+ "mCamelCase".
+- Template parameters are `CamelCase`.
+- Preprocessor macros are `UPPER_SNAKE_CASE`.
+
+## Justifications
+
+These sections explain why certain features are in FIT.
+
+### fit::Function
+
+- *libfidl*'s API needs a callable function wrapper with move semantics but
+ C++ 14's `std::function` only supports copyable function objects which forces
+ FIDL to allocate callback state on the heap making programs less efficient
+ and harder to write.
+- Lots of other C++ code uses callbacks extensively and would benefit from move
+ semantics for similar reasons.
+- So we should create a move-only function wrapper to use everywhere.
+
+### fit::Defer
+
+- When writing asynchronous event-driven programs, it can become challenging
+ to ensure that resources remain in scope for the duration of an operation
+ in progress and are subsequently released.
+- The C++ 14 standard library offers several classes with RAII semantics, such
+ as `std::unique_ptr`, which are helpful in these situations. Unfortunately the
+ C++ 14 standard library does not offer affordances for easily invoking a
+ function when a block or object goes out of scope short of implementing a
+ new class from scratch.
+- We have observed several re-implementations of the same idea throughout the
+ system.
+- So we should create a simple way to invoke a function on scope exit.
+
+### fit::Nullable
+
+- Case study: fit::defer has a need to store a closure that may be nullable.
+ We were able to replace its hand-rolled lifetime management code with
+ fit::nullable thereby vastly simplifying its implementation.
+- Case study: fit::future has a need to track its own validity along with
+ a continuation that may or not be present.
+- Case study: We have previously observed bugs where developers were
+ surprised when assigning a null closure to wrappers such as fit::function
+ fit::defer, or fit::future left these objects in a supposedly "valid"
+ but uninvocable state. These objects therefore take care to detect
+ null closures and enter an "invalid" state. Using fit::is_null and
+ fit::nullable makes it easier to eliminate this redundant state and
+ simplifies the API for clients of these wrappers.
+- std::optional can be effective here but it doesn't directly handle nullity
+ so it takes more care to coalesce the null and "not present" states.
+ std::optional also increases the size of the object to carry an extra
+ bool and passing, whereas fit::nullable eliminates this overhead by
+ taking advantage of the underlying value's null state (if there is one).
+- So we introduce fit::nullable to handle both cases systematically while
+ still hewing close to the semantics of std::optional.
diff --git a/android-emu/android/base/fit/ThreadChecker.h b/android-emu/android/base/fit/ThreadChecker.h
new file mode 100644
index 0000000..3859ecf
--- /dev/null
+++ b/android-emu/android/base/fit/ThreadChecker.h
@@ -0,0 +1,87 @@
+// Copyright 2021 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.
+
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// A class for checking that the current thread is/isn't the same as an initial
+// thread.
+
+#pragma once
+
+#include <assert.h>
+
+#include <thread>
+
+#include "ThreadSafety.h"
+
+namespace android::base {
+namespace fit {
+
+// A simple class that records the identity of the thread that it was created
+// on, and at later points can tell if the current thread is the same as its
+// creation thread. This class is thread-safe.
+//
+// In addition to providing an explicit check of the current thread,
+// |thread_checker| complies with BasicLockable, checking the current thread
+// when |lock| is called. This allows static thread safety analysis to be used
+// to ensure that resources are accessed in a context that is checked (at debug
+// runtime) to ensure that it's running on the correct thread:
+//
+// class MyClass {
+// public:
+// void Foo() {
+// std::lock_guard<fit::thread_checker> locker(thread_checker_);
+// resource_ = 0;
+// }
+// private:
+// fit::thread_checker thread_checker_;
+// int resource_ GUARDED_BY(thread_checker_);
+// }
+//
+// Note: |lock| checks the thread in debug builds only.
+//
+class CAPABILITY("mutex") ThreadChecker final {
+public:
+ // Default constructor. Constructs a thread checker bound to the currently
+ // running thread.
+ ThreadChecker() : self_(std::this_thread::get_id()) {}
+ // Constructs a thread checker bound to an explicit other thread.
+ explicit ThreadChecker(std::thread::id self) : self_(self) {}
+ ~ThreadChecker() = default;
+
+ // Returns true if the current thread is the thread this object was created
+ // on and false otherwise.
+ bool isThreadValid() const { return std::this_thread::get_id() == self_; }
+
+ // Implementation of the BaseLockable requirement
+ void lock() ACQUIRE() { assert(isThreadValid()); }
+
+ void unlock() RELEASE() {}
+
+private:
+ const std::thread::id self_;
+};
+
+#ifndef NDEBUG
+#define DECLARE_THREAD_CHECKER(c) android::base::fit::ThreadChecker c
+#define DCHECK_IS_THREAD_VALID(c) assert((c).isThreadValid())
+#else
+#define DECLARE_THREAD_CHECKER(c)
+#define DCHECK_IS_THREAD_VALID(c) ((void)0)
+#endif
+
+} // namespace fit
+} // namespace android::base
diff --git a/android-emu/android/base/fit/ThreadSafety.h b/android-emu/android/base/fit/ThreadSafety.h
new file mode 100644
index 0000000..bce528e
--- /dev/null
+++ b/android-emu/android/base/fit/ThreadSafety.h
@@ -0,0 +1,81 @@
+// Copyright 2021 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.
+
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+// Other libraries (e.g. libbase) may have already defined these symbols.
+// Only define them if they are not defined elsewhere.
+
+// Thread-safety annotations.
+// Currently these are only supported on Clang.
+#ifndef THREAD_ANNOTATION_ATTRIBUTE__
+#if defined(__clang__) && defined(_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS) && \
+ __has_attribute(acquire_capability)
+#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
+#else
+#define THREAD_ANNOTATION_ATTRIBUTE__(x)
+#endif
+#endif // THREAD_ANNOTATION_ATTRIBUTE__
+
+#ifndef CAPABILITY
+#define CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(__capability__(x))
+#endif // CAPABILITY
+
+#ifndef GUARDED_BY
+#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(__guarded_by__(x))
+#endif // GUARDED_BY
+
+#ifndef ACQUIRE
+#define ACQUIRE(...) THREAD_ANNOTATION_ATTRIBUTE__(__acquire_capability__(__VA_ARGS__))
+#endif // ACQUIRE
+
+#ifndef TRY_ACQUIRE
+#define TRY_ACQUIRE(...) THREAD_ANNOTATION_ATTRIBUTE__(__try_acquire_capability__(__VA_ARGS__))
+#endif // TRY_ACQUIRE
+
+#ifndef ACQUIRED_BEFORE
+#define ACQUIRED_BEFORE(...) THREAD_ANNOTATION_ATTRIBUTE__(__acquired_before__(__VA_ARGS__))
+#endif // ACQUIRED_BEFORE
+
+#ifndef ACQUIRED_AFTER
+#define ACQUIRED_AFTER(...) THREAD_ANNOTATION_ATTRIBUTE__(__acquired_after__(__VA_ARGS__))
+#endif // ACQUIRED_AFTER
+
+#ifndef RELEASE
+#define RELEASE(...) THREAD_ANNOTATION_ATTRIBUTE__(__release_capability__(__VA_ARGS__))
+#endif // RELEASE
+
+#ifndef REQUIRES
+#define REQUIRES(...) THREAD_ANNOTATION_ATTRIBUTE__(__requires_capability__(__VA_ARGS__))
+#endif // REQUIRES
+
+#ifndef EXCLUDES
+#define EXCLUDES(...) THREAD_ANNOTATION_ATTRIBUTE__(__locks_excluded__(__VA_ARGS__))
+#endif // EXCLUDES
+
+#ifndef RETURN_CAPABILITY
+#define RETURN_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(__lock_returned__(x))
+#endif // RETURN_CAPABILITY
+
+#ifndef SCOPED_CAPABILITY
+#define SCOPED_CAPABILITY THREAD_ANNOTATION_ATTRIBUTE__(__scoped_lockable__)
+#endif // SCOPED_CAPABILITY
+
+#ifndef NO_THREAD_SAFETY_ANALYSIS
+#define NO_THREAD_SAFETY_ANALYSIS THREAD_ANNOTATION_ATTRIBUTE__(__no_thread_safety_analysis__)
+#endif // NO_THREAD_SAFETY_ANALYSIS
diff --git a/android-emu/android/base/fit/UtilityInternal.h b/android-emu/android/base/fit/UtilityInternal.h
new file mode 100644
index 0000000..274105e
--- /dev/null
+++ b/android-emu/android/base/fit/UtilityInternal.h
@@ -0,0 +1,146 @@
+// Copyright 2021 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.
+
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+namespace android::base {
+namespace fit {
+namespace internal {
+
+// Utility to return the first type in a parameter pack.
+template <typename... Ts>
+struct First;
+template <typename FirstType, typename... Rest>
+struct First<FirstType, Rest...> {
+ using Type = FirstType;
+};
+
+template <typename... Ts>
+using First_t = typename First<Ts...>::Type;
+
+// Utility to count the occurences of type T in the parameter pack Ts.
+template <typename T, typename... Ts>
+struct OccurencesOf : std::integral_constant<size_t, 0> {};
+template <typename T, typename U>
+struct OccurencesOf<T, U> : std::integral_constant<size_t, std::is_same<T, U>::value> {};
+template <typename T, typename First, typename... Rest>
+struct OccurencesOf<T, First, Rest...>
+ : std::integral_constant<size_t,
+ OccurencesOf<T, First>::value + OccurencesOf<T, Rest...>::value> {};
+
+template <typename T, typename... Ts>
+constexpr size_t occurencesOf = OccurencesOf<T, Ts...>::value;
+
+// Utility to remove const, volatile, and reference qualifiers.
+template <typename T>
+using RemoveCvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+// Evaluates to truth-like when type T matches type U with cv-reference removed.
+template <typename T, typename U>
+using NotSameType = std::negation<std::is_same<T, RemoveCvref_t<U>>>;
+
+// Concept helper for constructors.
+template <typename... Conditions>
+using RequiresConditions = std::enable_if_t<std::conjunction_v<Conditions...>, bool>;
+
+// Concept helper for assignment operators.
+template <typename Return, typename... Conditions>
+using AssignmentRequiresConditions =
+ std::enable_if_t<std::conjunction_v<Conditions...>, std::add_lvalue_reference_t<Return>>;
+
+// Evaluates to true when every element type of Ts is trivially destructible.
+template <typename... Ts>
+constexpr bool isTriviallyDestructible = std::conjunction_v<std::is_trivially_destructible<Ts>...>;
+
+// Evaluates to true when every element type of Ts is trivially copyable.
+template <typename... Ts>
+constexpr bool isTriviallyCopyable =
+ (std::conjunction_v<std::is_trivially_copy_assignable<Ts>...> &&
+ std::conjunction_v<std::is_trivially_copy_constructible<Ts>...>);
+
+// Evaluates to true when every element type of Ts is trivially movable.
+template <typename... Ts>
+constexpr bool isTriviallyMovable =
+ (std::conjunction_v<std::is_trivially_move_assignable<Ts>...> &&
+ std::conjunction_v<std::is_trivially_move_constructible<Ts>...>);
+
+// Enable if relational operator is convertible to bool and the optional
+// conditions are true.
+template <typename Op, typename... Conditions>
+using enable_relop_t =
+ std::enable_if_t<(std::is_convertible<Op, bool>::value && std::conjunction_v<Conditions...>),
+ bool>;
+
+template <typename T>
+struct Identity {
+ using Type = T;
+};
+
+// Evaluates to true when T is an unbounded array.
+template <typename T>
+struct IsUnboundedArray : std::conjunction<std::is_array<T>, std::negation<std::extent<T>>> {};
+
+// Returns true when T is a complete type or an unbounded array.
+template <typename T, size_t = sizeof(T)>
+constexpr bool isCompleteOrUnboundedArray(Identity<T>) {
+ return true;
+}
+template <typename Identity, typename T = typename Identity::Type>
+constexpr bool isCompleteOrUnboundedArray(Identity) {
+ return std::disjunction<std::is_reference<T>, std::is_function<T>, std::is_void<T>,
+ IsUnboundedArray<T>>::value;
+}
+
+// Using swap for ADL. This directive is contained within the fit::internal
+// namespace, which prevents leaking std::swap into user namespaces. Doing this
+// at namespace scope is necessary to lookup swap via ADL while preserving the
+// noexcept() specification of the resulting lookup.
+using std::swap;
+
+// Evaluates to true when T is swappable.
+template <typename T, typename = void>
+struct IsSwappable : std::false_type {
+ static_assert(isCompleteOrUnboundedArray(Identity<T>{}),
+ "T must be a complete type or an unbounded array!");
+};
+template <typename T>
+struct IsSwappable<T, std::void_t<decltype(swap(std::declval<T&>(), std::declval<T&>()))>>
+ : std::true_type {
+ static_assert(isCompleteOrUnboundedArray(Identity<T>{}),
+ "T must be a complete type or an unbounded array!");
+};
+
+// Evaluates to true when T is nothrow swappable.
+template <typename T, typename = void>
+struct IsNothrowSwappable : std::false_type {
+ static_assert(isCompleteOrUnboundedArray(Identity<T>{}),
+ "T must be a complete type or an unbounded array!");
+};
+template <typename T>
+struct IsNothrowSwappable<T, std::void_t<decltype(swap(std::declval<T&>(), std::declval<T&>()))>>
+ : std::integral_constant<bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))> {
+ static_assert(isCompleteOrUnboundedArray(Identity<T>{}),
+ "T must be a complete type or an unbounded array!");
+};
+
+} // namespace internal
+} // namespace fit
+} // namespace android::base
diff --git a/android-emu/android/base/synchronization/AndroidConditionVariable.h b/android-emu/android/base/synchronization/AndroidConditionVariable.h
index 21cbdc0..b6ef088 100644
--- a/android-emu/android/base/synchronization/AndroidConditionVariable.h
+++ b/android-emu/android/base/synchronization/AndroidConditionVariable.h
@@ -41,13 +41,20 @@
// efficient to signal the variable before unlocking mutex, while on others
// (Windows) it's exactly the opposite. Functions implement the best way
// for each platform and abstract it out from the user.
- void signalAndUnlock(StaticLock* lock);
- void signalAndUnlock(AutoLock* lock);
+ template <bool IsRecursive>
+ void signalAndUnlock(StaticLock<IsRecursive>* lock);
- void broadcastAndUnlock(StaticLock* lock);
- void broadcastAndUnlock(AutoLock* lock);
+ template <class Lockable>
+ void signalAndUnlock(AutoLock<Lockable>* lock);
- void wait(AutoLock* userLock) {
+ template <bool IsRecursive>
+ void broadcastAndUnlock(StaticLock<IsRecursive>* lock);
+
+ template <class Lockable>
+ void broadcastAndUnlock(AutoLock<Lockable>* lock);
+
+ template <class Lockable>
+ void wait(AutoLock<Lockable>* userLock) {
assert(userLock->mLocked);
wait(&userLock->mLock);
}
@@ -70,15 +77,15 @@
// signature and returns a condition when one should stop waiting.
//
- template <class Predicate>
- void wait(StaticLock* lock, Predicate pred) {
+ template <bool IsRecursive, class Predicate>
+ void wait(StaticLock<IsRecursive>* lock, Predicate pred) {
while (!pred()) {
this->wait(lock);
}
}
- template <class Predicate>
- void wait(AutoLock* lock, Predicate pred) {
+ template <class Lockable, class Predicate>
+ void wait(AutoLock<Lockable>* lock, Predicate pred) {
this->wait(&lock->mLock, pred);
}
@@ -101,11 +108,13 @@
//
// if (!condition) { condVar.wait(&lock); }
//
- void wait(StaticLock* userLock) {
+ template <bool IsRecursive>
+ void wait(StaticLock<IsRecursive>* userLock) {
::SleepConditionVariableSRW(&mCond, &userLock->mLock, INFINITE, 0);
}
- bool timedWait(StaticLock *userLock, System::Duration waitUntilUs) {
+ template <bool IsRecursive>
+ bool timedWait(StaticLock<IsRecursive>* userLock, System::Duration waitUntilUs) {
const auto now = System::get()->getUnixTimeUs();
const auto timeout =
std::max<System::Duration>(0, waitUntilUs - now) / 1000;
@@ -139,18 +148,21 @@
pthread_cond_destroy(&mCond);
}
- void wait(StaticLock* userLock) {
+ template <bool IsRecursive>
+ void wait(StaticLock<IsRecursive>* userLock) {
pthread_cond_wait(&mCond, &userLock->mLock);
}
- bool timedWait(StaticLock* userLock, uint64_t waitUntilUs) {
+ template <bool IsRecursive>
+ bool timedWait(StaticLock<IsRecursive>* userLock, uint64_t waitUntilUs) {
timespec abstime;
abstime.tv_sec = waitUntilUs / 1000000LL;
abstime.tv_nsec = (waitUntilUs % 1000000LL) * 1000;
return timedWait(userLock, abstime);
}
- bool timedWait(StaticLock* userLock, const timespec& abstime) {
+ template <bool IsRecursive>
+ bool timedWait(StaticLock<IsRecursive>* userLock, const timespec& abstime) {
return pthread_cond_timedwait(&mCond, &userLock->mLock, &abstime) == 0;
}
@@ -171,37 +183,46 @@
};
#ifdef _WIN32
-inline void ConditionVariable::signalAndUnlock(StaticLock* lock) {
+template <bool IsRecursive>
+inline void ConditionVariable::signalAndUnlock(StaticLock<IsRecursive>* lock) {
lock->unlock();
signal();
}
-inline void ConditionVariable::signalAndUnlock(AutoLock* lock) {
+template <class Lockable>
+inline void ConditionVariable::signalAndUnlock(AutoLock<Lockable>* lock) {
lock->unlock();
signal();
}
-inline void ConditionVariable::broadcastAndUnlock(StaticLock* lock) {
+template <bool IsRecursive>
+inline void ConditionVariable::broadcastAndUnlock(StaticLock<IsRecursive>* lock) {
lock->unlock();
broadcast();
}
-inline void ConditionVariable::broadcastAndUnlock(AutoLock* lock) {
+template <class Lockable>
+inline void ConditionVariable::broadcastAndUnlock(AutoLock<Lockable>* lock) {
lock->unlock();
broadcast();
}
#else // !_WIN32
-inline void ConditionVariable::signalAndUnlock(StaticLock* lock) {
+
+template <bool IsRecursive>
+inline void ConditionVariable::signalAndUnlock(StaticLock<IsRecursive>* lock) {
signal();
lock->unlock();
}
-inline void ConditionVariable::signalAndUnlock(AutoLock* lock) {
+template <class Lockable>
+inline void ConditionVariable::signalAndUnlock(AutoLock<Lockable>* lock) {
signal();
lock->unlock();
}
-inline void ConditionVariable::broadcastAndUnlock(StaticLock* lock) {
+template <bool IsRecursive>
+inline void ConditionVariable::broadcastAndUnlock(StaticLock<IsRecursive>* lock) {
broadcast();
lock->unlock();
}
-inline void ConditionVariable::broadcastAndUnlock(AutoLock* lock) {
+template <class Lockable>
+inline void ConditionVariable::broadcastAndUnlock(AutoLock<Lockable>* lock) {
broadcast();
lock->unlock();
}
diff --git a/android-emu/android/base/synchronization/AndroidLock.h b/android-emu/android/base/synchronization/AndroidLock.h
index 74877d4..7b567f2 100644
--- a/android-emu/android/base/synchronization/AndroidLock.h
+++ b/android-emu/android/base/synchronization/AndroidLock.h
@@ -37,16 +37,22 @@
namespace base {
namespace guest {
+template <class Lockable>
class AutoLock;
+
class AutoWriteLock;
class AutoReadLock;
// A wrapper class for mutexes only suitable for using in static context,
-// where it's OK to leak the underlying system object. Use Lock for scoped or
-// member locks.
-class StaticLock {
+// where it's OK to leak the underlying system object.
+// Use Lock / RecursiveLock for scoped or member locks.
+template <bool IsRecursive>
+class StaticLock;
+
+template <>
+class StaticLock<false> {
public:
- using AutoLock = android::base::guest::AutoLock;
+ using AutoLock = android::base::guest::AutoLock<StaticLock>;
constexpr StaticLock() = default;
@@ -100,8 +106,72 @@
AEMU_IF_DEBUG(bool mIsLocked = false;)
};
+template <>
+class StaticLock<true> {
+public:
+ using AutoLock = android::base::guest::AutoLock<StaticLock>;
+
+ StaticLock() {
+#ifdef _WIN32
+ ::InitializeCriticalSectionAndSpinCount(&mLock, 0x400);
+#else
+ pthread_mutexattr_t attr;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+ pthread_mutex_init(&mLock, &attr);
+#endif
+ }
+
+ // Acquire the lock.
+ void lock() {
+#ifdef _WIN32
+ ::EnterCriticalSection(&mLock);
+#else
+ ::pthread_mutex_lock(&mLock);
+#endif
+ AEMU_IF_DEBUG(mIsLocked = true;)
+ }
+
+ bool tryLock() {
+ bool ret = false;
+#ifdef _WIN32
+ ret = ::TryEnterCriticalSection(&mLock);
+#else
+ ret = ::pthread_mutex_trylock(&mLock) == 0;
+#endif
+ AEMU_IF_DEBUG(mIsLocked = ret;)
+ return ret;
+ }
+
+ AEMU_IF_DEBUG(bool isLocked() const { return mIsLocked; })
+
+ // Release the lock.
+ void unlock() {
+ AEMU_IF_DEBUG(mIsLocked = false;)
+#ifdef _WIN32
+ ::LeaveCriticalSection(&mLock);
+#else
+ ::pthread_mutex_unlock(&mLock);
+#endif
+ }
+
+protected:
+ friend class ConditionVariable;
+
+#ifdef _WIN32
+ // We use CRITICAL_SECTION since it always allow recursive access.
+ CRITICAL_SECTION mLock;
+#else
+ pthread_mutex_t mLock = PTHREAD_MUTEX_INITIALIZER;
+#endif
+ // Both POSIX threads and WinAPI don't allow move (undefined behavior).
+ DISALLOW_COPY_ASSIGN_AND_MOVE(StaticLock);
+
+ AEMU_IF_DEBUG(bool mIsLocked = false;)
+};
+
// Simple wrapper class for mutexes used in non-static context.
-class Lock : public StaticLock {
+class Lock : public StaticLock<false> {
public:
using StaticLock::AutoLock;
@@ -113,6 +183,22 @@
#endif
};
+// Simple wrapper class for mutexes used in non-static context.
+class RecursiveLock : public StaticLock<true> {
+public:
+ using StaticLock::AutoLock;
+
+ RecursiveLock() = default;
+
+ ~RecursiveLock() {
+#ifdef _WIN32
+ ::DeleteCriticalSection(&mLock);
+#else
+ ::pthread_mutex_destroy(&mLock);
+#endif
+ }
+};
+
class ReadWriteLock {
public:
using AutoWriteLock = android::base::guest::AutoWriteLock;
@@ -147,11 +233,12 @@
// Helper class to lock / unlock a mutex automatically on scope
// entry and exit.
// NB: not thread-safe (as opposed to the Lock class)
+template <class Lockable>
class AutoLock {
public:
- AutoLock(StaticLock& lock) : mLock(lock) { mLock.lock(); }
+ AutoLock(Lockable& lock) : mLock(lock) { mLock.lock(); }
- AutoLock(AutoLock&& other) : mLock(other.mLock), mLocked(other.mLocked) {
+ AutoLock(AutoLock<Lockable>&& other) : mLock(other.mLock), mLocked(other.mLocked) {
other.mLocked = false;
}
@@ -176,7 +263,7 @@
}
private:
- StaticLock& mLock;
+ Lockable& mLock;
bool mLocked = true;
friend class ConditionVariable;
diff --git a/shared/GoldfishAddressSpace/include/goldfish_address_space.h b/shared/GoldfishAddressSpace/include/goldfish_address_space.h
index b824ace..1012629 100644
--- a/shared/GoldfishAddressSpace/include/goldfish_address_space.h
+++ b/shared/GoldfishAddressSpace/include/goldfish_address_space.h
@@ -68,10 +68,10 @@
#ifdef __Fuchsia__
std::unique_ptr<
- fuchsia_hardware_goldfish::AddressSpaceDevice::SyncClient>
+ ::fidl::WireSyncClient<fuchsia_hardware_goldfish::AddressSpaceDevice>>
m_device;
std::unique_ptr<
- fuchsia_hardware_goldfish::AddressSpaceChildDriver::SyncClient>
+ ::fidl::WireSyncClient<fuchsia_hardware_goldfish::AddressSpaceChildDriver>>
m_child_driver;
#else // __Fuchsia__
address_space_handle_t m_handle;
@@ -104,7 +104,7 @@
GoldfishAddressSpaceBlock &operator=(const GoldfishAddressSpaceBlock &);
#ifdef __Fuchsia__
- fuchsia_hardware_goldfish::AddressSpaceChildDriver::SyncClient*
+ ::fidl::WireSyncClient<fuchsia_hardware_goldfish::AddressSpaceChildDriver>*
m_driver;
uint32_t m_vmo;
#else // __Fuchsia__
diff --git a/shared/GoldfishAddressSpace/include/goldfish_address_space_fuchsia.impl b/shared/GoldfishAddressSpace/include/goldfish_address_space_fuchsia.impl
index e9acb4d..54d7e35 100644
--- a/shared/GoldfishAddressSpace/include/goldfish_address_space_fuchsia.impl
+++ b/shared/GoldfishAddressSpace/include/goldfish_address_space_fuchsia.impl
@@ -57,7 +57,7 @@
__FUNCTION__);
return;
}
- m_device = std::make_unique<AddressSpaceDevice::SyncClient>(std::move(channel));
+ m_device = std::make_unique<fidl::WireSyncClient<AddressSpaceDevice>>(std::move(channel));
auto child_driver_ends =
fidl::CreateEndpoints<::fuchsia_hardware_goldfish::AddressSpaceChildDriver>();
@@ -74,7 +74,7 @@
__FUNCTION__, result.status());
return;
}
- m_child_driver = std::make_unique<AddressSpaceChildDriver::SyncClient>(
+ m_child_driver = std::make_unique<fidl::WireSyncClient<AddressSpaceChildDriver>>(
std::move(child_driver_ends->client));
}
@@ -128,7 +128,7 @@
return false;
}
- AddressSpaceChildDriver::SyncClient* driver = provider->m_child_driver.get();
+ fidl::WireSyncClient<AddressSpaceChildDriver>* driver = provider->m_child_driver.get();
auto result = driver->AllocateBlock(size);
if (!result.ok() || result.Unwrap()->res != ZX_OK) {
@@ -308,15 +308,15 @@
__FUNCTION__);
return 0;
}
- AddressSpaceDevice::SyncClient*
- deviceSync = new AddressSpaceDevice::SyncClient(std::move(channel));
+ fidl::WireSyncClient<AddressSpaceDevice>*
+ deviceSync = new fidl::WireSyncClient<AddressSpaceDevice>(std::move(channel));
return (address_space_handle_t)deviceSync;
}
void goldfish_address_space_close(address_space_handle_t handle) {
- AddressSpaceDevice::SyncClient* deviceSync =
+ fidl::WireSyncClient<AddressSpaceDevice>* deviceSync =
reinterpret_cast<
- AddressSpaceDevice::SyncClient*>(handle);
+ fidl::WireSyncClient<AddressSpaceDevice>*>(handle);
delete deviceSync;
}
@@ -324,9 +324,9 @@
address_space_handle_t handle, GoldfishAddressSpaceSubdeviceType type,
address_space_handle_t* handle_out) {
- AddressSpaceDevice::SyncClient* deviceSync =
+ fidl::WireSyncClient<AddressSpaceDevice>* deviceSync =
reinterpret_cast<
- AddressSpaceDevice::SyncClient*>(handle);
+ fidl::WireSyncClient<AddressSpaceDevice>*>(handle);
auto child_driver_ends =
fidl::CreateEndpoints<::fuchsia_hardware_goldfish::AddressSpaceChildDriver>();
@@ -339,8 +339,8 @@
static_cast<AddressSpaceChildDriverType>(type),
std::move(child_driver_ends->server));
- AddressSpaceChildDriver::SyncClient*
- childSync = new AddressSpaceChildDriver::SyncClient(std::move(child_driver_ends->client));
+ fidl::WireSyncClient<AddressSpaceChildDriver>*
+ childSync = new fidl::WireSyncClient<AddressSpaceChildDriver>(std::move(child_driver_ends->client));
// On creating a subdevice, in our use cases we wont be needing the
// original device sync anymore, so get rid of it.
@@ -354,9 +354,9 @@
bool goldfish_address_space_allocate(
address_space_handle_t handle,
size_t size, uint64_t* phys_addr, uint64_t* offset) {
- AddressSpaceChildDriver::SyncClient* deviceSync =
+ fidl::WireSyncClient<AddressSpaceChildDriver>* deviceSync =
reinterpret_cast<
- AddressSpaceChildDriver::SyncClient*>(handle);
+ fidl::WireSyncClient<AddressSpaceChildDriver>*>(handle);
zx::vmo vmo;
auto result = deviceSync->AllocateBlock(size);
@@ -384,9 +384,9 @@
if (info.vmo == ZX_HANDLE_INVALID) return false;
zx_handle_close(info.vmo);
- AddressSpaceChildDriver::SyncClient* deviceSync =
+ fidl::WireSyncClient<AddressSpaceChildDriver>* deviceSync =
reinterpret_cast<
- AddressSpaceChildDriver::SyncClient*>(handle);
+ fidl::WireSyncClient<AddressSpaceChildDriver>*>(handle);
auto result = deviceSync->DeallocateBlock(info.phys_addr);
if (!result.ok() || result.Unwrap()->res != ZX_OK) {
@@ -400,9 +400,9 @@
bool goldfish_address_space_claim_shared(
address_space_handle_t handle, uint64_t offset, uint64_t size) {
- AddressSpaceChildDriver::SyncClient* deviceSync =
+ fidl::WireSyncClient<AddressSpaceChildDriver>* deviceSync =
reinterpret_cast<
- AddressSpaceChildDriver::SyncClient*>(handle);
+ fidl::WireSyncClient<AddressSpaceChildDriver>*>(handle);
zx::vmo vmo;
auto result = deviceSync->ClaimSharedBlock(offset, size);
@@ -423,9 +423,9 @@
bool goldfish_address_space_unclaim_shared(
address_space_handle_t handle, uint64_t offset) {
- AddressSpaceChildDriver::SyncClient* deviceSync =
+ fidl::WireSyncClient<AddressSpaceChildDriver>* deviceSync =
reinterpret_cast<
- AddressSpaceChildDriver::SyncClient*>(handle);
+ fidl::WireSyncClient<AddressSpaceChildDriver>*>(handle);
auto result = deviceSync->UnclaimSharedBlock(offset);
if (!result.ok() || result.Unwrap()->res != ZX_OK) {
@@ -469,9 +469,9 @@
AddressSpaceChildDriverPingMessage fuchsiaPing =
*(AddressSpaceChildDriverPingMessage*)ping;
- AddressSpaceChildDriver::SyncClient* deviceSync =
+ fidl::WireSyncClient<AddressSpaceChildDriver>* deviceSync =
reinterpret_cast<
- AddressSpaceChildDriver::SyncClient*>(handle);
+ fidl::WireSyncClient<AddressSpaceChildDriver>*>(handle);
AddressSpaceChildDriverPingMessage res;
auto result = deviceSync->Ping(fuchsiaPing);
diff --git a/shared/OpenglCodecCommon/GLClientState.cpp b/shared/OpenglCodecCommon/GLClientState.cpp
index 93f9d5d..0915341 100644
--- a/shared/OpenglCodecCommon/GLClientState.cpp
+++ b/shared/OpenglCodecCommon/GLClientState.cpp
@@ -1481,7 +1481,7 @@
return GL_NO_ERROR;
}
-void GLClientState::setBoundEGLImage(GLenum target, GLeglImageOES image) {
+void GLClientState::setBoundEGLImage(GLenum target, GLeglImageOES image, int width, int height) {
(void)image;
if (target == GL_RENDERBUFFER) {
@@ -1489,7 +1489,7 @@
setBoundRenderbufferEGLImageBacked();
setBoundRenderbufferFormat(GL_RGBA);
setBoundRenderbufferSamples(0);
- setBoundRenderbufferDimensions(1, 1);
+ setBoundRenderbufferDimensions(width, height);
} else {
GLuint texture = getBoundTexture(target);
TextureRec* texrec = getTextureRec(texture);
@@ -1499,7 +1499,7 @@
setBoundTextureFormat(target, GL_RGBA);
setBoundTextureType(target, GL_UNSIGNED_BYTE);
setBoundTextureSamples(target, 0);
- setBoundTextureDims(target, target, 0, 1, 1, 1);
+ setBoundTextureDims(target, target, 0, width, height, 1);
}
}
@@ -1760,7 +1760,9 @@
GLenum GLClientState::checkFramebufferCompleteness(GLenum target) {
// Default framebuffer is complete
// TODO: Check the case where the default framebuffer is 0x0
- if (0 == boundFramebuffer(target)) return GL_FRAMEBUFFER_COMPLETE;
+ if (0 == boundFramebuffer(target)) {
+ return GL_FRAMEBUFFER_COMPLETE;
+ }
bool hasAttachment = false;
FboProps& props = boundFboProps(target);
@@ -2469,6 +2471,10 @@
props.depthAttachment_hasRbo = false;
props.stencilAttachment_hasRbo = false;
props.depthstencilAttachment_hasRbo = false;
+
+ props.defaultWidth = 0;
+ props.defaultHeight = 0;
+
mFboState.fboData[name] = props;
}
diff --git a/shared/OpenglCodecCommon/GLClientState.h b/shared/OpenglCodecCommon/GLClientState.h
index c0ca53a..ff20287 100644
--- a/shared/OpenglCodecCommon/GLClientState.h
+++ b/shared/OpenglCodecCommon/GLClientState.h
@@ -414,7 +414,7 @@
// For accurate error detection, bindTexture should be called for *all*
// targets, not just 2D and EXTERNAL_OES.
GLenum bindTexture(GLenum target, GLuint texture, GLboolean* firstUse);
- void setBoundEGLImage(GLenum target, GLeglImageOES image);
+ void setBoundEGLImage(GLenum target, GLeglImageOES image, int width, int height);
// Return the texture currently bound to GL_TEXTURE_(2D|EXTERNAL_OES).
GLuint getBoundTexture(GLenum target) const;
diff --git a/shared/OpenglCodecCommon/GLSharedGroup.h b/shared/OpenglCodecCommon/GLSharedGroup.h
index 807a006..9832378 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.h
+++ b/shared/OpenglCodecCommon/GLSharedGroup.h
@@ -30,6 +30,7 @@
#include <GLES2/gl2ext.h>
#include <map>
+#include <memory>
#include <string>
#include <vector>
@@ -39,7 +40,6 @@
#include <utils/threads.h>
#include "auto_goldfish_dma_context.h"
#include "IndexRangeCache.h"
-#include "SmartPtr.h"
#include "StateTrackingSupport.h"
struct BufferData {
@@ -258,6 +258,6 @@
int getActiveAttributesCountForProgram(GLuint program);
};
-typedef SmartPtr<GLSharedGroup> GLSharedGroupPtr;
+typedef std::shared_ptr<GLSharedGroup> GLSharedGroupPtr;
#endif //_GL_SHARED_GROUP_H_
diff --git a/shared/OpenglCodecCommon/SmartPtr.h b/shared/OpenglCodecCommon/SmartPtr.h
deleted file mode 100644
index 3d821c8..0000000
--- a/shared/OpenglCodecCommon/SmartPtr.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-* 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.
-*/
-#ifndef __SMART_PTR_H
-#define __SMART_PTR_H
-
-#include <PortableMutex.h>
-
-#include <cutils/atomic.h>
-
-template <class T, bool threadSafe = false>
-class SmartPtr
-{
-public:
- explicit SmartPtr(T* ptr = (T*)NULL) {
- if (threadSafe) {
- m_lock = new mutex_t;
- mutex_init(m_lock);
- }
- else m_lock = NULL;
-
- m_ptr = ptr;
- if (ptr)
- m_pRefCount = new int32_t(1);
- else
- m_pRefCount = NULL;
- }
-
- SmartPtr<T,threadSafe>(const SmartPtr<T,false>& rhs) {
- if (threadSafe) {
- m_lock = new mutex_t;
- mutex_init(m_lock);
- }
- else m_lock = NULL;
-
- m_pRefCount = rhs.m_pRefCount;
- m_ptr = rhs.m_ptr;
- use();
- }
-
- SmartPtr<T,threadSafe>(SmartPtr<T,true>& rhs) {
- if (threadSafe) {
- m_lock = new mutex_t;
- mutex_init(m_lock);
- }
- else m_lock = NULL;
-
- if (rhs.m_lock) mutex_lock(rhs.m_lock);
- m_pRefCount = rhs.m_pRefCount;
- m_ptr = rhs.m_ptr;
- use();
- if (rhs.m_lock) mutex_unlock(rhs.m_lock);
- }
-
- ~SmartPtr() {
- if (m_lock) mutex_lock(m_lock);
- release();
- if (m_lock)
- {
- mutex_unlock(m_lock);
- mutex_destroy(m_lock);
- delete m_lock;
- }
- }
-
- T* Ptr() const {
- return m_ptr;
- }
-
- const T* constPtr() const
- {
- return m_ptr;
- }
-
- T* operator->() const {
- return m_ptr;
- }
-
- T& operator*() const {
- return *m_ptr;
- }
-
- operator void*() const {
- return (void *)m_ptr;
- }
-
- // This gives STL lists something to compare.
- bool operator <(const SmartPtr<T>& t1) const {
- return m_ptr < t1.m_ptr;
- }
-
- SmartPtr<T,threadSafe>& operator=(const SmartPtr<T,false>& rhs)
- {
- if (m_ptr == rhs.m_ptr)
- return *this;
-
- if (m_lock) mutex_lock(m_lock);
- release();
- m_pRefCount = rhs.m_pRefCount;
- m_ptr = rhs.m_ptr;
- use();
- if (m_lock) mutex_unlock(m_lock);
-
- return *this;
- }
-
- SmartPtr<T,threadSafe>& operator=(SmartPtr<T,true>& rhs)
- {
- if (m_ptr == rhs.m_ptr)
- return *this;
-
- if (m_lock) mutex_lock(m_lock);
- release();
- if (rhs.m_lock) mutex_lock(rhs.m_lock);
- m_pRefCount = rhs.m_pRefCount;
- m_ptr = rhs.m_ptr;
- use();
- if (rhs.m_lock) mutex_unlock(rhs.m_lock);
- if (m_lock) mutex_unlock(m_lock);
-
- return *this;
- }
-
-private:
- int32_t *m_pRefCount;
- mutex_t *m_lock;
- T* m_ptr;
-
- // Increment the reference count on this pointer by 1.
- int use() {
- if (!m_pRefCount) return 0;
- return android_atomic_inc(m_pRefCount) + 1;
- }
-
- // Decrement the reference count on the pointer by 1.
- // If the reference count goes to (or below) 0, the pointer is deleted.
- int release() {
- if (!m_pRefCount) return 0;
-
- int iVal = android_atomic_dec(m_pRefCount);
- if (iVal > 1)
- return iVal - 1;
-
- delete m_pRefCount;
- m_pRefCount = NULL;
-
- if (m_ptr) {
- delete m_ptr;
- m_ptr = NULL;
- }
- return 0;
- }
-
-};
-
-#endif // of __SMART_PTR_H
diff --git a/system/GLESv1_enc/GLEncoder.h b/system/GLESv1_enc/GLEncoder.h
index a26636c..7837838 100644
--- a/system/GLESv1_enc/GLEncoder.h
+++ b/system/GLESv1_enc/GLEncoder.h
@@ -33,7 +33,7 @@
}
void setSharedGroup(GLSharedGroupPtr shared) {
m_shared = shared;
- if (m_state && m_shared.Ptr())
+ if (m_state && m_shared)
m_state->setTextureData(m_shared->getTextureData());
}
void flush() { m_stream->flush(); }
diff --git a/system/GLESv2/gl2.cpp b/system/GLESv2/gl2.cpp
index 1c5ece7..9598a30 100644
--- a/system/GLESv2/gl2.cpp
+++ b/system/GLESv2/gl2.cpp
@@ -79,7 +79,7 @@
DEFINE_AND_VALIDATE_HOST_CONNECTION();
ctx->override2DTextureTarget(target);
- ctx->associateEGLImage(target, hostImage);
+ ctx->associateEGLImage(target, hostImage, image->width, image->height);
rcEnc->rcBindTexture(rcEnc,
grallocHelper->getHostHandle(native_buffer->handle));
ctx->restore2DTextureTarget(target);
@@ -87,7 +87,7 @@
else if (image->target == EGL_GL_TEXTURE_2D_KHR) {
GET_CONTEXT;
ctx->override2DTextureTarget(target);
- ctx->associateEGLImage(target, hostImage);
+ ctx->associateEGLImage(target, hostImage, image->width, image->height);
ctx->m_glEGLImageTargetTexture2DOES_enc(self, GL_TEXTURE_2D, hostImage);
ctx->restore2DTextureTarget(target);
}
@@ -116,7 +116,7 @@
DEFINE_AND_VALIDATE_HOST_CONNECTION();
GET_CONTEXT;
- ctx->associateEGLImage(target, hostImage);
+ ctx->associateEGLImage(target, hostImage, image->width, image->height);
rcEnc->rcBindRenderbuffer(rcEnc,
grallocHelper->getHostHandle(native_buffer->handle));
} else {
diff --git a/system/GLESv2_enc/GL2Encoder.cpp b/system/GLESv2_enc/GL2Encoder.cpp
index 931fa4e..9fcce62 100755
--- a/system/GLESv2_enc/GL2Encoder.cpp
+++ b/system/GLESv2_enc/GL2Encoder.cpp
@@ -41,7 +41,7 @@
static GLubyte *gExtensionsString= (GLubyte *) "GL_OES_EGL_image_external ";
#define SET_ERROR_IF(condition, err) if((condition)) { \
- ALOGE("%s:%s:%d GL error 0x%x\n", __FILE__, __FUNCTION__, __LINE__, err); \
+ ALOGE("%s:%s:%d GL error 0x%x condition [%s]\n", __FILE__, __FUNCTION__, __LINE__, err, #condition); \
ctx->setError(err); \
return; \
}
@@ -74,6 +74,7 @@
m_currMajorVersion = 2;
m_currMinorVersion = 0;
m_hasAsyncUnmapBuffer = false;
+ m_hasSyncBufferData = false;
m_initialized = false;
m_noHostError = false;
m_state = NULL;
@@ -668,7 +669,11 @@
ctx->m_shared->updateBufferData(bufferId, size, data);
ctx->m_shared->setBufferUsage(bufferId, usage);
- ctx->m_glBufferData_enc(self, target, size, data, usage);
+ if (ctx->m_hasSyncBufferData) {
+ ctx->glBufferDataSyncAEMU(self, target, size, data, usage);
+ } else {
+ ctx->m_glBufferData_enc(self, target, size, data, usage);
+ }
}
void GL2Encoder::s_glBufferSubData(void * self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data)
@@ -1104,10 +1109,14 @@
default:
if (!state) return;
- if (!state->getClientStateParameter<GLboolean>(param, ptr)) {
- ctx->safe_glGetBooleanv(param, ptr);
+ {
+ GLint intVal;
+ if (!state->getClientStateParameter<GLint>(param, &intVal)) {
+ ctx->safe_glGetBooleanv(param, ptr);
+ } else {
+ *ptr = (intVal != 0) ? GL_TRUE : GL_FALSE;
+ }
}
- *ptr = (*ptr != 0) ? GL_TRUE : GL_FALSE;
break;
}
}
@@ -1454,7 +1463,7 @@
if (!has_client_vertex_arrays && !has_indirect_arrays) {
// ALOGW("glDrawElements: no vertex arrays / buffers bound to the command\n");
- GLenum status = ctx->m_glCheckFramebufferStatus_enc(self, GL_FRAMEBUFFER);
+ GLenum status = ctx->glCheckFramebufferStatus(self, GL_FRAMEBUFFER);
SET_ERROR_IF(status != GL_FRAMEBUFFER_COMPLETE, GL_INVALID_FRAMEBUFFER_OPERATION);
}
@@ -1571,7 +1580,7 @@
if (!has_client_vertex_arrays && !has_indirect_arrays) {
// ALOGW("glDrawElements: no vertex arrays / buffers bound to the command\n");
- GLenum status = ctx->m_glCheckFramebufferStatus_enc(self, GL_FRAMEBUFFER);
+ GLenum status = ctx->glCheckFramebufferStatus(self, GL_FRAMEBUFFER);
SET_ERROR_IF(status != GL_FRAMEBUFFER_COMPLETE, GL_INVALID_FRAMEBUFFER_OPERATION);
}
@@ -1664,6 +1673,7 @@
// Replace uses of samplerExternalOES with sampler2D, recording the names of
// modified shaders in data. Also remove
// #extension GL_OES_EGL_image_external : require
+// #extension GL_OES_EGL_image_external_essl3 : require
// statements.
//
// This implementation assumes the input has already been pre-processed. If not,
@@ -1753,34 +1763,40 @@
}
char* sampler_start = c;
c += samplerExternalType.size();
- if (!isspace(*c) && *c != '\0') {
+ if (!isspace(*c) && *c != '\0' && *c != ';') {
continue;
+ } else {
+ // capture sampler name
+ while (isspace(*c) && *c != '\0') {
+ c++;
+ }
}
- // capture sampler name
- while (isspace(*c) && *c != '\0') {
- c++;
- }
- if (!isalpha(*c) && *c != '_') {
- // not an identifier
- return false;
- }
- char* name_start = c;
- do {
- c++;
- } while (isalnum(*c) || *c == '_');
+ if ((!isalpha(*c) && *c != '_') || *c == ';') {
+ // not an identifier, but might have some effect anyway.
+ if (samplerExternalType == STR_SAMPLER_EXTERNAL_OES) {
+ memcpy(sampler_start, STR_SAMPLER2D_SPACE, sizeof(STR_SAMPLER2D_SPACE)-1);
+ }
+ } else {
+ char* name_start = c;
+ do {
+ c++;
+ } while (isalnum(*c) || *c == '_');
- size_t len = (size_t)(c - name_start);
- data->samplerExternalNames.push_back(
- std::string(name_start, len));
+ size_t len = (size_t)(c - name_start);
+ if (len) {
+ data->samplerExternalNames.push_back(
+ std::string(name_start, len));
+ }
- // We only need to perform a string replacement for the original
- // occurrence of samplerExternalOES if a #define was used.
- //
- // The important part was to record the name in
- // |data->samplerExternalNames|.
- if (samplerExternalType == STR_SAMPLER_EXTERNAL_OES) {
- memcpy(sampler_start, STR_SAMPLER2D_SPACE, sizeof(STR_SAMPLER2D_SPACE)-1);
+ // We only need to perform a string replacement for the original
+ // occurrence of samplerExternalOES if a #define was used.
+ //
+ // The important part was to record the name in
+ // |data->samplerExternalNames|.
+ if (samplerExternalType == STR_SAMPLER_EXTERNAL_OES) {
+ memcpy(sampler_start, STR_SAMPLER2D_SPACE, sizeof(STR_SAMPLER2D_SPACE)-1);
+ }
}
}
@@ -2593,7 +2609,8 @@
SET_ERROR_IF(!GLESv2Validation::textureTarget(ctx, target), GL_INVALID_ENUM);
SET_ERROR_IF(!GLESv2Validation::pixelType(ctx, type), GL_INVALID_ENUM);
SET_ERROR_IF(!GLESv2Validation::pixelFormat(ctx, format), GL_INVALID_ENUM);
- SET_ERROR_IF(!GLESv2Validation::pixelFormat(ctx, internalformat) && !GLESv2Validation::pixelInternalFormat(internalformat), GL_INVALID_ENUM);
+ SET_ERROR_IF(!GLESv2Validation::pixelFormat(ctx, internalformat) && !GLESv2Validation::pixelInternalFormat(internalformat), GL_INVALID_VALUE);
+ SET_ERROR_IF(!(GLESv2Validation::pixelOp(format,type)),GL_INVALID_OPERATION);
SET_ERROR_IF(!GLESv2Validation::pixelSizedFormat(ctx, internalformat, format, type), GL_INVALID_OPERATION);
// If unpack buffer is nonzero, verify unmapped state.
SET_ERROR_IF(ctx->isBufferTargetMapped(GL_PIXEL_UNPACK_BUFFER), GL_INVALID_OPERATION);
@@ -2744,7 +2761,7 @@
GLClientState* state = ctx->m_state;
SET_ERROR_IF(!GLESv2Validation::textureTarget(ctx, target), GL_INVALID_ENUM);
- SET_ERROR_IF(!GLESv2Validation::pixelFormat(ctx, internalformat) && !GLESv2Validation::pixelInternalFormat(internalformat), GL_INVALID_ENUM);
+ SET_ERROR_IF(!GLESv2Validation::pixelFormat(ctx, internalformat) && !GLESv2Validation::pixelInternalFormat(internalformat), GL_INVALID_VALUE);
GLint max_texture_size;
GLint max_cube_map_texture_size;
ctx->glGetIntegerv(ctx, GL_MAX_TEXTURE_SIZE, &max_texture_size);
@@ -2847,8 +2864,8 @@
}
}
-void GL2Encoder::associateEGLImage(GLenum target, GLeglImageOES eglImage) {
- m_state->setBoundEGLImage(target, eglImage);
+void GL2Encoder::associateEGLImage(GLenum target, GLeglImageOES eglImage, int width, int height) {
+ m_state->setBoundEGLImage(target, eglImage, width, height);
}
@@ -2930,6 +2947,7 @@
GLClientState* state = ctx->m_state;
SET_ERROR_IF(target != GL_RENDERBUFFER, GL_INVALID_ENUM);
+ SET_ERROR_IF(0 == ctx->m_state->boundRenderbuffer(), GL_INVALID_OPERATION);
SET_ERROR_IF(
!GLESv2Validation::rboFormat(ctx, internalformat),
GL_INVALID_ENUM);
@@ -3356,6 +3374,7 @@
SET_ERROR_IF(!GLESv2Validation::textureTarget(ctx, target), GL_INVALID_ENUM);
SET_ERROR_IF(target == GL_TEXTURE_CUBE_MAP, GL_INVALID_ENUM);
+ fprintf(stderr, "%s: format: 0x%x\n", __func__, internalformat);
// Filter compressed formats support.
SET_ERROR_IF(!GLESv2Validation::supportedCompressedFormat(ctx, internalformat), GL_INVALID_ENUM);
// Verify level <= log2(GL_MAX_TEXTURE_SIZE).
@@ -4228,6 +4247,7 @@
GL_INVALID_ENUM);
SET_ERROR_IF(!GLESv2Validation::pixelType(ctx, type), GL_INVALID_ENUM);
SET_ERROR_IF(!GLESv2Validation::pixelFormat(ctx, format), GL_INVALID_ENUM);
+ SET_ERROR_IF(!(GLESv2Validation::pixelOp(format,type)),GL_INVALID_OPERATION);
SET_ERROR_IF(!GLESv2Validation::pixelSizedFormat(ctx, internalFormat, format, type), GL_INVALID_OPERATION);
SET_ERROR_IF(target == GL_TEXTURE_3D &&
((format == GL_DEPTH_COMPONENT) ||
@@ -4572,7 +4592,7 @@
if (!has_client_vertex_arrays && !has_indirect_arrays) {
// ALOGW("glDrawElements: no vertex arrays / buffers bound to the command\n");
- GLenum status = ctx->m_glCheckFramebufferStatus_enc(self, GL_FRAMEBUFFER);
+ GLenum status = ctx->glCheckFramebufferStatus(self, GL_FRAMEBUFFER);
SET_ERROR_IF(status != GL_FRAMEBUFFER_COMPLETE, GL_INVALID_FRAMEBUFFER_OPERATION);
}
@@ -4665,7 +4685,7 @@
if (!has_client_vertex_arrays && !has_indirect_arrays) {
// ALOGW("glDrawElements: no vertex arrays / buffers bound to the command\n");
- GLenum status = ctx->m_glCheckFramebufferStatus_enc(self, GL_FRAMEBUFFER);
+ GLenum status = ctx->glCheckFramebufferStatus(self, GL_FRAMEBUFFER);
SET_ERROR_IF(status != GL_FRAMEBUFFER_COMPLETE, GL_INVALID_FRAMEBUFFER_OPERATION);
}
@@ -6106,6 +6126,18 @@
GLuint tex = ctx->m_state->getBoundTexture(target);
GLsizei neededWidth = xoffset + width;
GLsizei neededHeight = yoffset + height;
+ ALOGV("%s: tex %u needed width height %d %d xoff %d width %d yoff %d height %d (texture width %d height %d) level %d\n", __func__,
+ tex,
+ neededWidth,
+ neededHeight,
+ xoffset,
+ width,
+ yoffset,
+ height,
+ ctx->m_state->queryTexWidth(level, tex),
+ ctx->m_state->queryTexWidth(level, tex),
+ level);
+
SET_ERROR_IF(tex &&
(neededWidth > ctx->m_state->queryTexWidth(level, tex) ||
neededHeight > ctx->m_state->queryTexHeight(level, tex)),
@@ -6554,6 +6586,7 @@
GL2Encoder* ctx = (GL2Encoder*)self;
SET_ERROR_IF(target != GL_RENDERBUFFER, GL_INVALID_ENUM);
SET_ERROR_IF(!GLESv2Validation::allowedGetRenderbufferParameter(pname), GL_INVALID_ENUM);
+ SET_ERROR_IF(0 == ctx->m_state->boundRenderbuffer(), GL_INVALID_OPERATION);
ctx->m_glGetRenderbufferParameteriv_enc(ctx, target, pname, params);
}
diff --git a/system/GLESv2_enc/GL2Encoder.h b/system/GLESv2_enc/GL2Encoder.h
index 93108eb..90978be 100644
--- a/system/GLESv2_enc/GL2Encoder.h
+++ b/system/GLESv2_enc/GL2Encoder.h
@@ -35,6 +35,9 @@
void setHasAsyncUnmapBuffer(int version) {
m_hasAsyncUnmapBuffer = version;
}
+ void setHasSyncBufferData(bool value) {
+ m_hasSyncBufferData = value;
+ }
void setNoHostError(bool noHostError) {
m_noHostError = noHostError;
}
@@ -62,7 +65,7 @@
}
void setSharedGroup(GLSharedGroupPtr shared) {
m_shared = shared;
- if (m_state && m_shared.Ptr()) {
+ if (m_state && m_shared) {
m_state->setTextureData(m_shared->getTextureData());
m_state->setRenderbufferInfo(m_shared->getRenderbufferInfo());
m_state->setSamplerInfo(m_shared->getSamplerInfo());
@@ -94,7 +97,7 @@
void override2DTextureTarget(GLenum target);
void restore2DTextureTarget(GLenum target);
- void associateEGLImage(GLenum target, GLeglImageOES eglImage);
+ void associateEGLImage(GLenum target, GLeglImageOES eglImage, int width, int height);
// Convenience functions for buffers
GLuint boundBuffer(GLenum target) const;
@@ -113,6 +116,7 @@
std::vector<std::string> m_currExtensionsArray;
bool m_hasAsyncUnmapBuffer;
+ bool m_hasSyncBufferData;
bool m_initialized;
bool m_noHostError;
GLClientState *m_state;
diff --git a/system/GLESv2_enc/gl2_client_context.cpp b/system/GLESv2_enc/gl2_client_context.cpp
index aaa0325..49b52a7 100644
--- a/system/GLESv2_enc/gl2_client_context.cpp
+++ b/system/GLESv2_enc/gl2_client_context.cpp
@@ -436,6 +436,7 @@
glDrawElementsDataNullAEMU = (glDrawElementsDataNullAEMU_client_proc_t) getProc("glDrawElementsDataNullAEMU", userData);
glUnmapBufferAsyncAEMU = (glUnmapBufferAsyncAEMU_client_proc_t) getProc("glUnmapBufferAsyncAEMU", userData);
glFlushMappedBufferRangeAEMU2 = (glFlushMappedBufferRangeAEMU2_client_proc_t) getProc("glFlushMappedBufferRangeAEMU2", userData);
+ glBufferDataSyncAEMU = (glBufferDataSyncAEMU_client_proc_t) getProc("glBufferDataSyncAEMU", userData);
return 0;
}
diff --git a/system/GLESv2_enc/gl2_client_context.h b/system/GLESv2_enc/gl2_client_context.h
index 575395a..b3d5f70 100644
--- a/system/GLESv2_enc/gl2_client_context.h
+++ b/system/GLESv2_enc/gl2_client_context.h
@@ -436,6 +436,7 @@
glDrawElementsDataNullAEMU_client_proc_t glDrawElementsDataNullAEMU;
glUnmapBufferAsyncAEMU_client_proc_t glUnmapBufferAsyncAEMU;
glFlushMappedBufferRangeAEMU2_client_proc_t glFlushMappedBufferRangeAEMU2;
+ glBufferDataSyncAEMU_client_proc_t glBufferDataSyncAEMU;
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 615b123..268cb99 100644
--- a/system/GLESv2_enc/gl2_client_proc.h
+++ b/system/GLESv2_enc/gl2_client_proc.h
@@ -438,6 +438,7 @@
typedef void (gl2_APIENTRY *glDrawElementsDataNullAEMU_client_proc_t) (void * ctx, GLenum, GLsizei, GLenum, void*, GLuint);
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);
#endif
diff --git a/system/GLESv2_enc/gl2_enc.cpp b/system/GLESv2_enc/gl2_enc.cpp
index d997f29..e610c86 100644
--- a/system/GLESv2_enc/gl2_enc.cpp
+++ b/system/GLESv2_enc/gl2_enc.cpp
@@ -11918,6 +11918,52 @@
}
+GLboolean glBufferDataSyncAEMU_enc(void *self , GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
+{
+ AEMU_SCOPED_TRACE("glBufferDataSyncAEMU 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;
+
+ const unsigned int __size_data = ((data != NULL) ? size : 0);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glBufferDataSyncAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &target, 4); ptr += 4;
+ memcpy(ptr, &size, 4); ptr += 4;
+ memcpy(ptr, &__size_data, 4); ptr += 4;
+ if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data;
+ memcpy(ptr, &usage, 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("glBufferDataSyncAEMU: 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)
@@ -12351,5 +12397,6 @@
this->glDrawElementsDataNullAEMU = &glDrawElementsDataNullAEMU_enc;
this->glUnmapBufferAsyncAEMU = &glUnmapBufferAsyncAEMU_enc;
this->glFlushMappedBufferRangeAEMU2 = &glFlushMappedBufferRangeAEMU2_enc;
+ this->glBufferDataSyncAEMU = &glBufferDataSyncAEMU_enc;
}
diff --git a/system/GLESv2_enc/gl2_entry.cpp b/system/GLESv2_enc/gl2_entry.cpp
index a5d6c87..5ea44c2 100644
--- a/system/GLESv2_enc/gl2_entry.cpp
+++ b/system/GLESv2_enc/gl2_entry.cpp
@@ -431,6 +431,7 @@
void glDrawElementsDataNullAEMU(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen);
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);
};
#ifndef GET_CONTEXT
@@ -3032,3 +3033,9 @@
ctx->glFlushMappedBufferRangeAEMU2(ctx, target, offset, length, access, guest_buffer);
}
+GLboolean glBufferDataSyncAEMU(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
+{
+ GET_CONTEXT;
+ return ctx->glBufferDataSyncAEMU(ctx, target, size, data, usage);
+}
+
diff --git a/system/GLESv2_enc/gl2_opcodes.h b/system/GLESv2_enc/gl2_opcodes.h
index 9c619e1..25ab3e7 100644
--- a/system/GLESv2_enc/gl2_opcodes.h
+++ b/system/GLESv2_enc/gl2_opcodes.h
@@ -429,7 +429,8 @@
#define OP_glDrawElementsDataNullAEMU 2471
#define OP_glUnmapBufferAsyncAEMU 2472
#define OP_glFlushMappedBufferRangeAEMU2 2473
-#define OP_last 2474
+#define OP_glBufferDataSyncAEMU 2474
+#define OP_last 2475
#endif
diff --git a/system/OpenglSystemCommon/AddressSpaceStream.cpp b/system/OpenglSystemCommon/AddressSpaceStream.cpp
index 53b5285..84d635a 100644
--- a/system/OpenglSystemCommon/AddressSpaceStream.cpp
+++ b/system/OpenglSystemCommon/AddressSpaceStream.cpp
@@ -152,14 +152,22 @@
return nullptr;
}
#else
+static address_space_handle_t openVirtGpuAddressSpace() {
+ address_space_handle_t ret;
+ uint8_t retryCount = 64;
+ do {
+ ret = virtgpu_address_space_open();
+ } while(ret < 0 && retryCount-- > 0 && errno == EINTR);
+ return ret;
+}
+
AddressSpaceStream* createVirtioGpuAddressSpaceStream(size_t ignored_bufSize) {
// Ignore incoming ignored_bufSize
(void)ignored_bufSize;
- auto handle = virtgpu_address_space_open();
-
- if (handle == reinterpret_cast<address_space_handle_t>(-1)) {
- ALOGE("AddressSpaceStream::create failed (open device)\n");
+ auto handle = openVirtGpuAddressSpace();
+ if (handle <= reinterpret_cast<address_space_handle_t>(-1)) {
+ ALOGE("AddressSpaceStream::create failed (open device) %d (%s)\n", errno, strerror(errno));
return nullptr;
}
diff --git a/system/OpenglSystemCommon/EGLImage.h b/system/OpenglSystemCommon/EGLImage.h
index a83e1ad..8a1eb6d 100644
--- a/system/OpenglSystemCommon/EGLImage.h
+++ b/system/OpenglSystemCommon/EGLImage.h
@@ -36,6 +36,8 @@
{
EGLDisplay dpy;
EGLenum target;
+ int width;
+ int height;
union
{
diff --git a/system/OpenglSystemCommon/EmulatorFeatureInfo.h b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
index f4467bb..f6d8ce5 100644
--- a/system/OpenglSystemCommon/EmulatorFeatureInfo.h
+++ b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
@@ -125,6 +125,10 @@
// Queue submit with commands
static const char kVulkanQueueSubmitWithCommands[] = "ANDROID_EMU_vulkan_queue_submit_with_commands";
+//
+// Synchronized glBufferData call
+static const char kSyncBufferData[] = "ANDROID_EMU_sync_buffer_data";
+
// Batched descriptor set update
static const char kVulkanBatchedDescriptorSetUpdate[] = "ANDROID_EMU_vulkan_batched_descriptor_set_update";
@@ -154,7 +158,8 @@
hasHostSideTracing(false),
hasAsyncFrameCommands(false),
hasVulkanQueueSubmitWithCommands(false),
- hasVulkanBatchedDescriptorSetUpdate(false)
+ hasVulkanBatchedDescriptorSetUpdate(false),
+ hasSyncBufferData(false)
{ }
SyncImpl syncImpl;
@@ -179,6 +184,7 @@
bool hasAsyncFrameCommands;
bool hasVulkanQueueSubmitWithCommands;
bool hasVulkanBatchedDescriptorSetUpdate;
+ bool hasSyncBufferData;
};
enum HostConnectionType {
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index 417b87e..4afa20e 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -40,6 +40,7 @@
void setNoHostError(bool) { }
void setDrawCallFlushInterval(uint32_t) { }
void setHasAsyncUnmapBuffer(int) { }
+ void setHasSyncBufferData(int) { }
};
#else
#include "GLEncoder.h"
@@ -105,16 +106,18 @@
return HOST_CONNECTION_ADDRESS_SPACE;
#else
char transportValue[PROPERTY_VALUE_MAX] = "";
- property_get("ro.kernel.qemu.gltransport", transportValue, "");
- bool isValid = transportValue[0] != '\0';
+ do {
+ property_get("ro.boot.qemu.gltransport.name", transportValue, "");
+ if (transportValue[0]) { break; }
- if (!isValid) {
+ property_get("ro.boot.qemu.gltransport", transportValue, "");
+ if (transportValue[0]) { break; }
+
property_get("ro.boot.hardware.gltransport", transportValue, "");
- isValid = transportValue[0] != '\0';
- }
+ } while (false);
- if (!isValid) return HOST_CONNECTION_QEMU_PIPE;
+ if (!transportValue[0]) return HOST_CONNECTION_QEMU_PIPE;
if (!strcmp("tcp", transportValue)) return HOST_CONNECTION_TCP;
if (!strcmp("pipe", transportValue)) return HOST_CONNECTION_QEMU_PIPE;
@@ -128,29 +131,24 @@
}
static uint32_t getDrawCallFlushIntervalFromProperty() {
+ constexpr uint32_t kDefaultValue = 800;
+
char flushValue[PROPERTY_VALUE_MAX] = "";
- property_get("ro.kernel.qemu.gltransport.drawFlushInterval", flushValue, "");
+ property_get("ro.boot.qemu.gltransport.drawFlushInterval", flushValue, "");
+ if (!flushValue[0]) return kDefaultValue;
- bool isValid = flushValue[0] != '\0';
- if (!isValid) return 800;
-
- long interval = strtol(flushValue, 0, 10);
-
- if (!interval) return 800;
-
- return (uint32_t)interval;
+ const long interval = strtol(flushValue, 0, 10);
+ return (interval > 0) ? uint32_t(interval) : kDefaultValue;
}
static GrallocType getGrallocTypeFromProperty() {
- char prop[PROPERTY_VALUE_MAX] = "";
- property_get("ro.hardware.gralloc", prop, "");
+ char value[PROPERTY_VALUE_MAX] = "";
+ property_get("ro.hardware.gralloc", value, "");
- bool isValid = prop[0] != '\0';
+ if (!value[0]) return GRALLOC_TYPE_RANCHU;
- if (!isValid) return GRALLOC_TYPE_RANCHU;
-
- if (!strcmp("ranchu", prop)) return GRALLOC_TYPE_RANCHU;
- if (!strcmp("minigbm", prop)) return GRALLOC_TYPE_MINIGBM;
+ if (!strcmp("ranchu", value)) return GRALLOC_TYPE_RANCHU;
+ if (!strcmp("minigbm", value)) return GRALLOC_TYPE_MINIGBM;
return GRALLOC_TYPE_RANCHU;
}
@@ -628,6 +626,7 @@
m_gl2Enc->setDrawCallFlushInterval(
getDrawCallFlushIntervalFromProperty());
m_gl2Enc->setHasAsyncUnmapBuffer(m_rcEnc->hasAsyncUnmapBuffer());
+ m_gl2Enc->setHasSyncBufferData(m_rcEnc->hasSyncBufferData());
}
return m_gl2Enc.get();
}
@@ -672,6 +671,8 @@
queryAndSetAsyncFrameCommands(rcEnc);
queryAndSetVulkanQueueSubmitWithCommandsSupport(rcEnc);
queryAndSetVulkanBatchedDescriptorSetUpdateSupport(rcEnc);
+ queryAndSetSyncBufferData(rcEnc);
+ queryVersion(rcEnc);
if (m_processPipe) {
m_processPipe->processPipeInit(m_connectionType, rcEnc);
}
@@ -962,3 +963,15 @@
rcEnc->featureInfo()->hasVulkanBatchedDescriptorSetUpdate = true;
}
}
+
+void HostConnection::queryAndSetSyncBufferData(ExtendedRCEncoderContext* rcEnc) {
+ std::string glExtensions = queryGLExtensions(rcEnc);
+ if (glExtensions.find(kSyncBufferData) != std::string::npos) {
+ rcEnc->featureInfo()->hasSyncBufferData = true;
+ }
+}
+
+GLint HostConnection::queryVersion(ExtendedRCEncoderContext* rcEnc) {
+ GLint version = m_rcEnc->rcGetRendererVersion(m_rcEnc.get());
+ return version;
+}
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index c1c3f40..7c55629 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -75,6 +75,8 @@
bool hasAsyncFrameCommands() const {
return m_featureInfo.hasAsyncFrameCommands;
}
+ bool hasSyncBufferData() const {
+ return m_featureInfo.hasSyncBufferData; }
DmaImpl getDmaVersion() const { return m_featureInfo.dmaImpl; }
void bindDmaContext(struct goldfish_dma_context* cxt) { m_dmaCxt = cxt; }
void bindDmaDirectly(void* dmaPtr, uint64_t dmaPhysAddr) {
@@ -239,6 +241,8 @@
void queryAndSetAsyncFrameCommands(ExtendedRCEncoderContext *rcEnc);
void queryAndSetVulkanQueueSubmitWithCommandsSupport(ExtendedRCEncoderContext *rcEnc);
void queryAndSetVulkanBatchedDescriptorSetUpdateSupport(ExtendedRCEncoderContext *rcEnc);
+ void queryAndSetSyncBufferData(ExtendedRCEncoderContext *rcEnc);
+ GLint queryVersion(ExtendedRCEncoderContext* rcEnc);
private:
HostConnectionType m_connectionType;
diff --git a/system/OpenglSystemCommon/ProcessPipe.cpp b/system/OpenglSystemCommon/ProcessPipe.cpp
index 047ba34..c7254d1 100644
--- a/system/OpenglSystemCommon/ProcessPipe.cpp
+++ b/system/OpenglSystemCommon/ProcessPipe.cpp
@@ -83,7 +83,7 @@
return;
}
- fuchsia_hardware_goldfish::PipeDevice::SyncClient device(
+ fidl::WireSyncClient<fuchsia_hardware_goldfish::PipeDevice> device(
std::move(channel));
auto pipe_ends =
@@ -93,7 +93,7 @@
return;
}
- fuchsia_hardware_goldfish::Pipe::SyncClient pipe(
+ fidl::WireSyncClient<fuchsia_hardware_goldfish::Pipe> pipe(
std::move(pipe_ends->client));
device.OpenPipe(std::move(pipe_ends->server));
diff --git a/system/OpenglSystemCommon/QemuPipeStream.h b/system/OpenglSystemCommon/QemuPipeStream.h
index 24a4d6f..e6aad15 100644
--- a/system/OpenglSystemCommon/QemuPipeStream.h
+++ b/system/OpenglSystemCommon/QemuPipeStream.h
@@ -59,9 +59,9 @@
size_t m_read;
size_t m_readLeft;
#ifdef __Fuchsia__
- std::unique_ptr<fuchsia_hardware_goldfish::PipeDevice::SyncClient>
+ std::unique_ptr<::fidl::WireSyncClient<fuchsia_hardware_goldfish::PipeDevice>>
m_device;
- std::unique_ptr<fuchsia_hardware_goldfish::Pipe::SyncClient>
+ std::unique_ptr<::fidl::WireSyncClient<fuchsia_hardware_goldfish::Pipe>>
m_pipe;
zx::event m_event;
zx::vmo m_vmo;
diff --git a/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp b/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
index c7e7512..f445244 100644
--- a/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
+++ b/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
@@ -81,7 +81,7 @@
}
m_device = std::make_unique<
- fuchsia_hardware_goldfish::PipeDevice::SyncClient>(
+ fidl::WireSyncClient<fuchsia_hardware_goldfish::PipeDevice>>(
std::move(channel));
auto pipe_ends =
@@ -92,7 +92,7 @@
}
m_device->OpenPipe(std::move(pipe_ends->server));
m_pipe =
- std::make_unique<fuchsia_hardware_goldfish::Pipe::SyncClient>(
+ std::make_unique<fidl::WireSyncClient<fuchsia_hardware_goldfish::Pipe>>(
std::move(pipe_ends->client));
zx::event event;
@@ -304,14 +304,14 @@
zx_signals_t observed = ZX_SIGNAL_NONE;
zx_status_t status = m_event.wait_one(
- fuchsia_hardware_goldfish::wire::SIGNAL_READABLE |
- fuchsia_hardware_goldfish::wire::SIGNAL_HANGUP,
+ fuchsia_hardware_goldfish::wire::kSignalReadable |
+ fuchsia_hardware_goldfish::wire::kSignalHangup,
zx::time::infinite(), &observed);
if (status != ZX_OK) {
ALOGD("%s: wait_one failed: %d", __FUNCTION__, status);
return nullptr;
}
- if (observed & fuchsia_hardware_goldfish::wire::SIGNAL_HANGUP) {
+ if (observed & fuchsia_hardware_goldfish::wire::kSignalHangup) {
ALOGD("%s: Remote end hungup", __FUNCTION__);
return nullptr;
}
diff --git a/system/codecs/c2/decoders/avcdec/C2GoldfishAvcDec.cpp b/system/codecs/c2/decoders/avcdec/C2GoldfishAvcDec.cpp
index b2011b1..a991603 100644
--- a/system/codecs/c2/decoders/avcdec/C2GoldfishAvcDec.cpp
+++ b/system/codecs/c2/decoders/avcdec/C2GoldfishAvcDec.cpp
@@ -38,6 +38,8 @@
#include <goldfish_codec2/store/GoldfishComponentStore.h>
#include <gralloc_cb_bp.h>
+#include <color_buffer_utils.h>
+
#include "C2GoldfishAvcDec.h"
#define DEBUG 0
@@ -405,12 +407,20 @@
void C2GoldfishAvcDec::onReset() { (void)onStop(); }
void C2GoldfishAvcDec::onRelease() {
- (void)deleteDecoder();
+ deleteContext();
if (mOutBlock) {
mOutBlock.reset();
}
}
+void C2GoldfishAvcDec::decodeHeaderAfterFlush() {
+ if (mContext && !mCsd0.empty() && !mCsd1.empty()) {
+ mContext->decodeFrame(&(mCsd0[0]), mCsd0.size(), 0);
+ mContext->decodeFrame(&(mCsd1[0]), mCsd1.size(), 0);
+ DDD("resending csd0 and csd1");
+ }
+}
+
c2_status_t C2GoldfishAvcDec::onFlush_sm() {
if (OK != setFlushMode())
return C2_CORRUPTED;
@@ -428,7 +438,6 @@
return C2_NO_MEMORY;
}
- mContext->flush();
while (true) {
mPts = 0;
setDecodeArgs(nullptr, nullptr, 0, 0, 0);
@@ -444,6 +453,7 @@
mOutBufferFlush = nullptr;
}
+ deleteContext();
return C2_OK;
}
@@ -467,7 +477,7 @@
status_t C2GoldfishAvcDec::initDecoder() {
// if (OK != createDecoder()) return UNKNOWN_ERROR;
- mStride = ALIGN32(mWidth);
+ mStride = ALIGN16(mWidth);
mSignalledError = false;
resetPlugin();
@@ -493,8 +503,7 @@
mInPBuffer = const_cast<uint8_t *>(inBuffer->data() + inOffset);
mInPBufferSize = inSize;
mInTsMarker = tsMarker;
- mIndex2Pts[mInTsMarker] = mPts;
- mPts2Index[mPts] = mInTsMarker;
+ insertPts(tsMarker, mPts);
}
// uint32_t displayHeight = mHeight;
@@ -510,12 +519,11 @@
return true;
}
-bool C2GoldfishAvcDec::getVuiParams() { return true; }
-
status_t C2GoldfishAvcDec::setFlushMode() {
if (mContext) {
mContext->flush();
}
+ mHeaderDecoded = false;
return OK;
}
@@ -523,13 +531,7 @@
mStride = 0;
mSignalledError = false;
mHeaderDecoded = false;
- if (mContext) {
- // The resolution may have changed, so our safest bet is to just destroy
- // the current context and recreate another one, with the new width and
- // height.
- mContext->destroyH264Context();
- mContext.reset(nullptr);
- }
+ deleteContext();
return OK;
}
@@ -540,12 +542,14 @@
gettimeofday(&mTimeEnd, nullptr);
}
-status_t C2GoldfishAvcDec::deleteDecoder() {
+void C2GoldfishAvcDec::deleteContext() {
if (mContext) {
mContext->destroyH264Context();
mContext.reset(nullptr);
+ mPts2Index.clear();
+ mOldPts2Index.clear();
+ mIndex2Pts.clear();
}
- return OK;
}
static void fillEmptyWork(const std::unique_ptr<C2Work> &work) {
@@ -554,6 +558,7 @@
flags |= C2FrameData::FLAG_END_OF_STREAM;
DDD("signalling eos");
}
+ DDD("fill empty work");
work->worklets.front()->output.flags = (C2FrameData::flags_t)flags;
work->worklets.front()->output.buffers.clear();
work->worklets.front()->output.ordinal = work->input.ordinal;
@@ -630,21 +635,19 @@
c2_status_t
C2GoldfishAvcDec::ensureDecoderState(const std::shared_ptr<C2BlockPool> &pool) {
- if (mOutBlock && (mOutBlock->width() != ALIGN32(mWidth) ||
+ if (mOutBlock && (mOutBlock->width() != ALIGN16(mWidth) ||
mOutBlock->height() != mHeight)) {
mOutBlock.reset();
}
if (!mOutBlock) {
- // uint32_t format = HAL_PIXEL_FORMAT_YCBCR_420_888;//19;
- // //HAL_PIXEL_FORMAT_YV12;
- uint32_t format = 19; // HAL_PIXEL_FORMAT_YV12;
+ uint32_t format = HAL_PIXEL_FORMAT_YCBCR_420_888;
C2MemoryUsage usage = {C2MemoryUsage::CPU_READ,
C2MemoryUsage::CPU_WRITE};
usage.expected = (uint64_t)(BufferUsage::GPU_DATA_BUFFER);
// C2MemoryUsage usage = {(unsigned
// int)(BufferUsage::GPU_DATA_BUFFER)};// { C2MemoryUsage::CPU_READ,
// C2MemoryUsage::CPU_WRITE };
- c2_status_t err = pool->fetchGraphicBlock(ALIGN32(mWidth), mHeight,
+ c2_status_t err = pool->fetchGraphicBlock(ALIGN16(mWidth), mHeight,
format, usage, &mOutBlock);
if (err != C2_OK) {
ALOGE("fetchGraphicBlock for Output failed with status %d", err);
@@ -654,20 +657,11 @@
auto c2Handle = mOutBlock->handle();
native_handle_t *grallocHandle =
UnwrapNativeCodec2GrallocHandle(c2Handle);
- cb_handle_t *cbhandle = (cb_handle_t *)grallocHandle;
- DDD("found handle %d", cbhandle->hostHandle);
- mHostColorBufferId = cbhandle->hostHandle;
- } else {
- C2GraphicView wView = mOutBlock->map().get();
- if (wView.error()) {
- ALOGE("graphic view map failed %d", wView.error());
- return C2_CORRUPTED;
- }
- mByteBuffer =
- const_cast<uint8_t *>(wView.data()[C2PlanarLayout::PLANE_Y]);
+ mHostColorBufferId = getColorBufferHandle(grallocHandle);
+ DDD("found handle %d", mHostColorBufferId);
}
DDD("provided (%dx%d) required (%dx%d)", mOutBlock->width(),
- mOutBlock->height(), ALIGN32(mWidth), mHeight);
+ mOutBlock->height(), ALIGN16(mWidth), mHeight);
}
return C2_OK;
@@ -678,7 +672,7 @@
mHeight = mIntf->height();
{
// now get the block
- constexpr uint32_t format = 19;
+ constexpr uint32_t format = HAL_PIXEL_FORMAT_YCBCR_420_888;
std::shared_ptr<C2GraphicBlock> block;
C2MemoryUsage usage = {C2MemoryUsage::CPU_READ,
C2MemoryUsage::CPU_WRITE};
@@ -693,8 +687,7 @@
auto c2Handle = block->handle();
native_handle_t *grallocHandle =
UnwrapNativeCodec2GrallocHandle(c2Handle);
- cb_handle_t *cbhandle = (cb_handle_t *)grallocHandle;
- int hostColorBufferId = cbhandle->hostHandle;
+ int hostColorBufferId = getColorBufferHandle(grallocHandle);
if (hostColorBufferId > 0) {
DDD("decoding to host color buffer");
mEnableAndroidNativeBuffers = true;
@@ -705,33 +698,125 @@
}
}
-void C2GoldfishAvcDec::copyImageData(uint8_t *pBuffer, h264_image_t &img) {
+void C2GoldfishAvcDec::getVuiParams(h264_image_t &img) {
+
+ VuiColorAspects vuiColorAspects;
+ vuiColorAspects.primaries = img.color_primaries;
+ vuiColorAspects.transfer = img.color_trc;
+ vuiColorAspects.coeffs = img.colorspace;
+ vuiColorAspects.fullRange = img.color_range == 2 ? true : false;
+
+ // convert vui aspects to C2 values if changed
+ if (!(vuiColorAspects == mBitstreamColorAspects)) {
+ mBitstreamColorAspects = vuiColorAspects;
+ ColorAspects sfAspects;
+ C2StreamColorAspectsInfo::input codedAspects = {0u};
+ ColorUtils::convertIsoColorAspectsToCodecAspects(
+ vuiColorAspects.primaries, vuiColorAspects.transfer,
+ vuiColorAspects.coeffs, vuiColorAspects.fullRange, sfAspects);
+ if (!C2Mapper::map(sfAspects.mPrimaries, &codedAspects.primaries)) {
+ codedAspects.primaries = C2Color::PRIMARIES_UNSPECIFIED;
+ }
+ if (!C2Mapper::map(sfAspects.mRange, &codedAspects.range)) {
+ codedAspects.range = C2Color::RANGE_UNSPECIFIED;
+ }
+ if (!C2Mapper::map(sfAspects.mMatrixCoeffs, &codedAspects.matrix)) {
+ codedAspects.matrix = C2Color::MATRIX_UNSPECIFIED;
+ }
+ if (!C2Mapper::map(sfAspects.mTransfer, &codedAspects.transfer)) {
+ codedAspects.transfer = C2Color::TRANSFER_UNSPECIFIED;
+ }
+ std::vector<std::unique_ptr<C2SettingResult>> failures;
+ (void)mIntf->config({&codedAspects}, C2_MAY_BLOCK, &failures);
+ }
+}
+
+void C2GoldfishAvcDec::copyImageData(h264_image_t &img) {
+ getVuiParams(img);
if (mEnableAndroidNativeBuffers)
return;
- int myStride = mWidth;
- for (int i = 0; i < mHeight; ++i) {
- memcpy(pBuffer + i * myStride, img.data + i * mWidth, mWidth);
+
+ auto writeView = mOutBlock->map().get();
+ if (writeView.error()) {
+ ALOGE("graphic view map failed %d", writeView.error());
+ return;
}
- int Y = myStride * mHeight;
+ size_t dstYStride = writeView.layout().planes[C2PlanarLayout::PLANE_Y].rowInc;
+ size_t dstUVStride = writeView.layout().planes[C2PlanarLayout::PLANE_U].rowInc;
+
+ uint8_t *pYBuffer = const_cast<uint8_t *>(writeView.data()[C2PlanarLayout::PLANE_Y]);
+ uint8_t *pUBuffer = const_cast<uint8_t *>(writeView.data()[C2PlanarLayout::PLANE_U]);
+ uint8_t *pVBuffer = const_cast<uint8_t *>(writeView.data()[C2PlanarLayout::PLANE_V]);
+
+ for (int i = 0; i < mHeight; ++i) {
+ memcpy(pYBuffer + i * dstYStride, img.data + i * mWidth, mWidth);
+ }
for (int i = 0; i < mHeight / 2; ++i) {
- memcpy(pBuffer + Y + i * myStride / 2,
+ memcpy(pUBuffer + i * dstUVStride,
img.data + mWidth * mHeight + i * mWidth / 2, mWidth / 2);
}
- int UV = Y / 4;
for (int i = 0; i < mHeight / 2; ++i) {
- memcpy(pBuffer + Y + UV + i * myStride / 2,
+ memcpy(pVBuffer + i * dstUVStride,
img.data + mWidth * mHeight * 5 / 4 + i * mWidth / 2,
mWidth / 2);
}
}
-void C2GoldfishAvcDec::removePts(uint64_t pts) {
+uint64_t C2GoldfishAvcDec::getWorkIndex(uint64_t pts) {
+ if (!mOldPts2Index.empty()) {
+ auto iter = mOldPts2Index.find(pts);
+ if (iter != mOldPts2Index.end()) {
+ auto index = iter->second;
+ DDD("found index %d for pts %" PRIu64, (int)index, pts);
+ return index;
+ }
+ }
auto iter = mPts2Index.find(pts);
- if (iter == mPts2Index.end()) return;
+ if (iter != mPts2Index.end()) {
+ auto index = iter->second;
+ DDD("found index %d for pts %" PRIu64, (int)index, pts);
+ return index;
+ }
+ DDD("not found index for pts %" PRIu64, pts);
+ return 0;
+}
- auto index = iter->second;
+void C2GoldfishAvcDec::insertPts(uint32_t work_index, uint64_t pts) {
+ auto iter = mPts2Index.find(pts);
+ if (iter != mPts2Index.end()) {
+ // we have a collision here:
+ // apparently, older session is not done yet,
+ // lets save them
+ DDD("inserted to old pts %" PRIu64 " with index %d", pts, (int)iter->second);
+ mOldPts2Index[iter->first] = iter->second;
+ }
+ DDD("inserted pts %" PRIu64 " with index %d", pts, (int)work_index);
+ mIndex2Pts[work_index] = pts;
+ mPts2Index[pts] = work_index;
+}
- mPts2Index.erase(iter);
+void C2GoldfishAvcDec::removePts(uint64_t pts) {
+ bool found = false;
+ uint64_t index = 0;
+ // note: check old pts first to see
+ // if we have some left over, check them
+ if (!mOldPts2Index.empty()) {
+ auto iter = mOldPts2Index.find(pts);
+ if (iter != mOldPts2Index.end()) {
+ mOldPts2Index.erase(iter);
+ index = iter->second;
+ found = true;
+ }
+ } else {
+ auto iter = mPts2Index.find(pts);
+ if (iter != mPts2Index.end()) {
+ mPts2Index.erase(iter);
+ index = iter->second;
+ found = true;
+ }
+ }
+
+ if (!found) return;
auto iter2 = mIndex2Pts.find(index);
if (iter2 == mIndex2Pts.end()) return;
@@ -761,6 +846,7 @@
DDD("creating decoder context to host in process work");
checkMode(pool);
createDecoder();
+ decodeHeaderAfterFlush();
}
size_t inOffset = 0u;
@@ -779,7 +865,7 @@
}
}
bool eos = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0);
- bool hasPicture = false;
+ bool hasPicture = (inSize > 0);
DDD("in buffer attr. size %zu timestamp %d frameindex %d, flags %x", inSize,
(int)work->input.ordinal.timestamp.peeku(),
@@ -813,6 +899,20 @@
setParams(mStride);
}
+ DDD("flag is %x", work->input.flags);
+ if (work->input.flags & C2FrameData::FLAG_CODEC_CONFIG) {
+ hasPicture = false;
+ if (mCsd0.empty()) {
+ mCsd0.assign(mInPBuffer, mInPBuffer + mInPBufferSize);
+ DDD("assign to csd0 with %d bytpes", mInPBufferSize);
+ } else if (mCsd1.empty()) {
+ mCsd1.assign(mInPBuffer, mInPBuffer + mInPBufferSize);
+ DDD("assign to csd1 with %d bytpes", mInPBufferSize);
+ }
+ // this is not really a valid pts from config
+ removePts(mPts);
+ }
+
uint32_t delay;
GETTIME(&mTimeStart, nullptr);
TIME_DIFF(mTimeEnd, mTimeStart, delay);
@@ -821,6 +921,7 @@
h264_result_t h264Res =
mContext->decodeFrame(mInPBuffer, mInPBufferSize, mIndex2Pts[mInTsMarker]);
mConsumedBytes = h264Res.bytesProcessed;
+ DDD("decoding consumed %d", (int)mConsumedBytes);
if (mHostColorBufferId > 0) {
mImg = mContext->renderOnHostAndReturnImageMetadata(
@@ -845,12 +946,34 @@
// (void) ivdec_api_function(mDecHandle, &s_decode_ip,
// &s_decode_op);
}
- (void)getVuiParams();
if (mImg.data != nullptr) {
- DDD("got data %" PRIu64, mPts2Index[mImg.pts]);
- hasPicture = true;
- copyImageData(mByteBuffer, mImg);
- finishWork(mPts2Index[mImg.pts], work);
+ // check for new width and height
+ auto decodedW = mImg.width;
+ auto decodedH = mImg.height;
+ if (decodedW != mWidth || decodedH != mHeight) {
+ mWidth = decodedW;
+ mHeight = decodedH;
+
+ C2StreamPictureSizeInfo::output size(0u, mWidth, mHeight);
+ std::vector<std::unique_ptr<C2SettingResult>> failures;
+ c2_status_t err = mIntf->config({&size}, C2_MAY_BLOCK, &failures);
+ if (err == OK) {
+ work->worklets.front()->output.configUpdate.push_back(
+ C2Param::Copy(size));
+ ensureDecoderState(pool);
+ } else {
+ ALOGE("Cannot set width and height");
+ mSignalledError = true;
+ work->workletsProcessed = 1u;
+ work->result = C2_CORRUPTED;
+ return;
+ }
+ }
+
+ DDD("got data %" PRIu64 " with pts %" PRIu64, getWorkIndex(mImg.pts), mImg.pts);
+ mHeaderDecoded = true;
+ copyImageData(mImg);
+ finishWork(getWorkIndex(mImg.pts), work);
removePts(mImg.pts);
} else {
work->workletsProcessed = 0u;
@@ -863,8 +986,8 @@
drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work);
mSignalledOutputEos = true;
} else if (!hasPicture) {
+ DDD("no picture, fill empty work");
fillEmptyWork(work);
- work->workletsProcessed = 0u;
}
work->input.buffers.clear();
@@ -915,9 +1038,9 @@
// TODO: maybe keep rendering to screen
// mImg = mContext->getImage();
if (mImg.data != nullptr) {
- DDD("got data in drain mode %" PRIu64, mPts2Index[mImg.pts]);
- copyImageData(mByteBuffer, mImg);
- finishWork(mPts2Index[mImg.pts], work);
+ DDD("got data in drain mode %" PRIu64 " with pts %" PRIu64, getWorkIndex(mImg.pts), mImg.pts);
+ copyImageData(mImg);
+ finishWork(getWorkIndex(mImg.pts), work);
removePts(mImg.pts);
} else {
fillEmptyWork(work);
diff --git a/system/codecs/c2/decoders/avcdec/C2GoldfishAvcDec.h b/system/codecs/c2/decoders/avcdec/C2GoldfishAvcDec.h
index 57b1d69..3c5be7f 100644
--- a/system/codecs/c2/decoders/avcdec/C2GoldfishAvcDec.h
+++ b/system/codecs/c2/decoders/avcdec/C2GoldfishAvcDec.h
@@ -28,6 +28,7 @@
namespace android {
+#define ALIGN16(x) ((((x) + 15) >> 4) << 4)
#define ALIGN32(x) ((((x) + 31) >> 5) << 5)
#define MAX_NUM_CORES 4
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
@@ -65,7 +66,6 @@
status_t initDecoder();
bool setDecodeArgs(C2ReadView *inBuffer, C2GraphicView *outBuffer,
size_t inOffset, size_t inSize, uint32_t tsMarker);
- bool getVuiParams();
c2_status_t ensureDecoderState(const std::shared_ptr<C2BlockPool> &pool);
void finishWork(uint64_t index, const std::unique_ptr<C2Work> &work);
status_t setFlushMode();
@@ -74,12 +74,17 @@
const std::unique_ptr<C2Work> &work);
status_t resetDecoder();
void resetPlugin();
- status_t deleteDecoder();
+ void deleteContext();
std::shared_ptr<IntfImpl> mIntf;
void removePts(uint64_t pts);
+ void insertPts(uint32_t work_index, uint64_t pts);
+ uint64_t getWorkIndex(uint64_t pts);
+ // there are same pts matching to different work indices
+ // this happen during csd0/csd1 switching
+ std::map<uint64_t, uint64_t> mOldPts2Index;
std::map<uint64_t, uint64_t> mPts2Index;
std::map<uint64_t, uint64_t> mIndex2Pts;
uint64_t mPts {0};
@@ -98,9 +103,9 @@
int mHostColorBufferId{-1};
- void copyImageData(uint8_t *pBuffer, h264_image_t &img);
+ void getVuiParams(h264_image_t &img);
+ void copyImageData(h264_image_t &img);
- uint8_t *mByteBuffer{nullptr};
h264_image_t mImg{};
uint32_t mConsumedBytes{0};
uint8_t *mInPBuffer{nullptr};
@@ -141,6 +146,10 @@
char mInFile[200];
#endif /* FILE_DUMP_ENABLE */
+ std::vector<uint8_t> mCsd0;
+ std::vector<uint8_t> mCsd1;
+ void decodeHeaderAfterFlush();
+
C2_DO_NOT_COPY(C2GoldfishAvcDec);
};
diff --git a/system/codecs/c2/decoders/base/Android.bp b/system/codecs/c2/decoders/base/Android.bp
index f4ebb5d..58e26a3 100644
--- a/system/codecs/c2/decoders/base/Android.bp
+++ b/system/codecs/c2/decoders/base/Android.bp
@@ -18,6 +18,7 @@
"SimpleC2Component.cpp",
"SimpleC2Interface.cpp",
"goldfish_media_utils.cpp",
+ "color_buffer_utils.cpp",
],
export_include_dirs: [
@@ -33,6 +34,7 @@
"libcutils", // for properties
"liblog", // for ALOG
"libdrm", // for ALOG
+ "libbase", // for properties, parseint
"libsfplugin_ccodec_utils", // for ImageCopy
"libstagefright_foundation", // for Mutexed
"libgoldfish_codec2_store", // for goldfish store
@@ -42,6 +44,10 @@
"libGoldfishAddressSpace",
],
+ header_libs: [
+ "libgralloc_cb.ranchu",
+ ],
+
sanitize: {
misc_undefined: [
"unsigned-integer-overflow",
diff --git a/system/codecs/c2/decoders/base/color_buffer_utils.cpp b/system/codecs/c2/decoders/base/color_buffer_utils.cpp
new file mode 100644
index 0000000..36aa336
--- /dev/null
+++ b/system/codecs/c2/decoders/base/color_buffer_utils.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2021 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 <inttypes.h>
+#include <android-base/parseint.h>
+#include <android-base/properties.h>
+#include <android-base/strings.h>
+#include <log/log.h>
+#include <gralloc_cb_bp.h>
+#include <drm/virtgpu_drm.h>
+#include <xf86drm.h>
+
+#include "cros_gralloc_handle.h"
+
+static bool isMinigbmFromProperty() {
+ static constexpr const auto kGrallocProp = "ro.hardware.gralloc";
+
+ const auto grallocProp = android::base::GetProperty(kGrallocProp, "");
+ ALOGD("%s:codecs: minigbm query prop value is: %s", __FUNCTION__, grallocProp.c_str());
+
+ if (grallocProp == "minigbm") {
+ ALOGD("%s:codecs: Using minigbm, in minigbm mode.\n", __FUNCTION__);
+ return true;
+ } else {
+ ALOGD("%s:codecs: Is not using minigbm, in goldfish mode.\n", __FUNCTION__);
+ return false;
+ }
+}
+
+class ColorBufferUtilsGlobalState {
+public:
+ ColorBufferUtilsGlobalState() {
+ m_isMinigbm = isMinigbmFromProperty();
+
+ if (m_isMinigbm) {
+ static constexpr int kRendernodeMinor = 128;
+ m_rendernodeFd = drmOpenRender(kRendernodeMinor);
+ }
+ }
+
+ uint32_t getColorBufferHandle(native_handle_t const* handle) {
+ if (m_isMinigbm) {
+ struct drm_virtgpu_resource_info info;
+ if (!getResInfo(handle, &info)) {
+ ALOGE("%s: Error gtting color buffer handle (minigbm case)", __func__);
+ return -1;
+ }
+ return info.res_handle;
+ } else {
+ return cb_handle_t::from(handle)->hostHandle;
+ }
+ }
+
+private:
+
+ bool getResInfo(native_handle_t const* handle,
+ struct drm_virtgpu_resource_info* info) {
+ memset(info, 0x0, sizeof(*info));
+ if (m_rendernodeFd < 0) {
+ ALOGE("%s: Error, rendernode fd missing\n", __func__);
+ return false;
+ }
+
+ struct drm_gem_close gem_close;
+ memset(&gem_close, 0x0, sizeof(gem_close));
+
+ cros_gralloc_handle const* cros_handle =
+ reinterpret_cast<cros_gralloc_handle const*>(handle);
+
+ uint32_t prime_handle;
+ int ret = drmPrimeFDToHandle(m_rendernodeFd, cros_handle->fds[0], &prime_handle);
+ if (ret) {
+ ALOGE("%s: DRM_IOCTL_PRIME_FD_TO_HANDLE failed: %s (errno %d)\n",
+ __func__, strerror(errno), errno);
+ return false;
+ }
+
+ info->bo_handle = prime_handle;
+ gem_close.handle = prime_handle;
+
+ ret = drmIoctl(m_rendernodeFd, DRM_IOCTL_VIRTGPU_RESOURCE_INFO, info);
+ if (ret) {
+ ALOGE("%s: DRM_IOCTL_VIRTGPU_RESOURCE_INFO failed: %s (errno %d)\n",
+ __func__, strerror(errno), errno);
+ drmIoctl(m_rendernodeFd, DRM_IOCTL_GEM_CLOSE, &gem_close);
+ return false;
+ }
+
+ drmIoctl(m_rendernodeFd, DRM_IOCTL_GEM_CLOSE, &gem_close);
+ return true;
+ }
+
+ bool m_isMinigbm;
+ int m_rendernodeFd = -1; // to be closed when this process dies
+};
+
+static ColorBufferUtilsGlobalState* getGlobals() {
+ static ColorBufferUtilsGlobalState* globals = new ColorBufferUtilsGlobalState;
+ return globals;
+}
+
+uint32_t getColorBufferHandle(native_handle_t const* handle) {
+ return getGlobals()->getColorBufferHandle(handle);
+}
diff --git a/system/codecs/c2/decoders/base/cros_gralloc_handle.h b/system/codecs/c2/decoders/base/cros_gralloc_handle.h
new file mode 100644
index 0000000..2b70d4b
--- /dev/null
+++ b/system/codecs/c2/decoders/base/cros_gralloc_handle.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef CROS_GRALLOC_HANDLE_H
+#define CROS_GRALLOC_HANDLE_H
+
+#include <cstdint>
+#include <cutils/native_handle.h>
+
+#define DRV_MAX_PLANES 4
+#define DRV_MAX_FDS (DRV_MAX_PLANES + 1)
+
+struct cros_gralloc_handle : public native_handle_t {
+ /*
+ * File descriptors must immediately follow the native_handle_t base and used file
+ * descriptors must be packed at the beginning of this array to work with
+ * native_handle_clone().
+ *
+ * This field contains 'num_planes' plane file descriptors followed by an optional metadata
+ * reserved region file descriptor if 'reserved_region_size' is greater than zero.
+ */
+ int32_t fds[DRV_MAX_FDS];
+ uint32_t strides[DRV_MAX_PLANES];
+ uint32_t offsets[DRV_MAX_PLANES];
+ uint32_t sizes[DRV_MAX_PLANES];
+ uint32_t id;
+ uint32_t width;
+ uint32_t height;
+ uint32_t format; /* DRM format */
+ uint32_t tiling;
+ uint64_t format_modifier;
+ uint64_t use_flags; /* Buffer creation flags */
+ uint32_t magic;
+ uint32_t pixel_stride;
+ int32_t droid_format;
+ int32_t usage; /* Android usage. */
+ uint32_t num_planes;
+ uint64_t reserved_region_size;
+ uint64_t total_size; /* Total allocation size */
+ /*
+ * Name is a null terminated char array located at handle->base.data[handle->name_offset].
+ */
+ uint32_t name_offset;
+} __attribute__((packed));
+
+typedef const struct cros_gralloc_handle *cros_gralloc_handle_t;
+
+#endif
diff --git a/system/codecs/c2/decoders/base/include/color_buffer_utils.h b/system/codecs/c2/decoders/base/include/color_buffer_utils.h
new file mode 100644
index 0000000..d0a7876
--- /dev/null
+++ b/system/codecs/c2/decoders/base/include/color_buffer_utils.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2021 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/native_handle.h>
+
+uint32_t getColorBufferHandle(native_handle_t const* handle);
diff --git a/system/codecs/c2/decoders/vpxdec/C2GoldfishVpxDec.cpp b/system/codecs/c2/decoders/vpxdec/C2GoldfishVpxDec.cpp
index a01ae84..7df99ff 100644
--- a/system/codecs/c2/decoders/vpxdec/C2GoldfishVpxDec.cpp
+++ b/system/codecs/c2/decoders/vpxdec/C2GoldfishVpxDec.cpp
@@ -38,6 +38,8 @@
#include <gralloc_cb_bp.h>
+#include <color_buffer_utils.h>
+
#include "C2GoldfishVpxDec.h"
#define DEBUG 0
@@ -87,8 +89,8 @@
DefineParam(mSize, C2_PARAMKEY_PICTURE_SIZE)
.withDefault(new C2StreamPictureSizeInfo::output(0u, 320, 240))
.withFields({
- C2F(mSize, width).inRange(2, 2048, 2),
- C2F(mSize, height).inRange(2, 2048, 2),
+ C2F(mSize, width).inRange(2, 4096, 2),
+ C2F(mSize, height).inRange(2, 4096, 2),
})
.withSetter(SizeSetter)
.build());
@@ -176,8 +178,8 @@
.withDefault(new C2StreamMaxPictureSizeTuning::output(
0u, 320, 240))
.withFields({
- C2F(mSize, width).inRange(2, 2048, 2),
- C2F(mSize, height).inRange(2, 2048, 2),
+ C2F(mSize, width).inRange(2, 4096, 2),
+ C2F(mSize, height).inRange(2, 4096, 2),
})
.withSetter(MaxPictureSizeSetter, mSize)
.build());
@@ -240,17 +242,25 @@
const C2P<C2StreamPictureSizeInfo::output> &oldMe,
C2P<C2StreamPictureSizeInfo::output> &me) {
(void)mayBlock;
- DDD("calling sizesetter now %d", oldMe.v.height);
- DDD("new calling sizesetter now %d", me.v.height);
+ DDD("calling sizesetter old w %d", oldMe.v.width);
+ DDD("calling sizesetter old h %d", oldMe.v.height);
+ DDD("calling sizesetter change to w %d", me.v.width);
+ DDD("calling sizesetter change to h %d", me.v.height);
C2R res = C2R::Ok();
- if (!me.F(me.v.width).supportsAtAll(me.v.width)) {
+ auto mewidth = me.F(me.v.width);
+ auto meheight = me.F(me.v.height);
+
+ if (!mewidth.supportsAtAll(me.v.width)) {
res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.width)));
+ DDD("override width with oldMe value");
me.set().width = oldMe.v.width;
+ DDD("something wrong here %s %d", __func__, __LINE__);
}
- if (!me.F(me.v.height).supportsAtAll(me.v.height)) {
+ if (!meheight.supportsAtAll(me.v.height)) {
res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.height)));
- DDD("override with oldMe value");
+ DDD("override height with oldMe value");
me.set().height = oldMe.v.height;
+ DDD("something wrong here %s %d", __func__, __LINE__);
}
return res;
}
@@ -262,8 +272,8 @@
(void)mayBlock;
// TODO: get max width/height from the size's field helpers vs.
// hardcoding
- me.set().width = c2_min(c2_max(me.v.width, size.v.width), 2048u);
- me.set().height = c2_min(c2_max(me.v.height, size.v.height), 2048u);
+ me.set().width = c2_min(c2_max(me.v.width, size.v.width), 4096u);
+ me.set().height = c2_min(c2_max(me.v.height, size.v.height), 4096u);
return C2R::Ok();
}
@@ -458,7 +468,7 @@
// check for decoding mode:
{
// now get the block
- constexpr uint32_t format = 19;
+ constexpr uint32_t format = HAL_PIXEL_FORMAT_YCBCR_420_888;
std::shared_ptr<C2GraphicBlock> block;
C2MemoryUsage usage = {C2MemoryUsage::CPU_READ,
C2MemoryUsage::CPU_WRITE};
@@ -473,8 +483,7 @@
auto c2Handle = block->handle();
native_handle_t *grallocHandle =
UnwrapNativeCodec2GrallocHandle(c2Handle);
- cb_handle_t *cbhandle = (cb_handle_t *)grallocHandle;
- int hostColorBufferId = cbhandle->hostHandle;
+ int hostColorBufferId = getColorBufferHandle(grallocHandle);
if (hostColorBufferId > 0) {
DDD("decoding to host color buffer");
mEnableAndroidNativeBuffers = true;
@@ -699,10 +708,9 @@
return BAD_VALUE;
// now get the block
- uint32_t format = HAL_PIXEL_FORMAT_YV12;
std::shared_ptr<C2GraphicBlock> block;
C2MemoryUsage usage = {C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE};
- format = 19; // HAL_PIXEL_FORMAT_YV12;
+ uint32_t format = HAL_PIXEL_FORMAT_YCBCR_420_888;
usage.expected = (uint64_t)(BufferUsage::GPU_DATA_BUFFER);
c2_status_t err = pool->fetchGraphicBlock(align(mWidth, 2), mHeight, format,
@@ -718,8 +726,7 @@
auto c2Handle = block->handle();
native_handle_t *grallocHandle =
UnwrapNativeCodec2GrallocHandle(c2Handle);
- cb_handle_t *cbhandle = (cb_handle_t *)grallocHandle;
- int hostColorBufferId = cbhandle->hostHandle;
+ int hostColorBufferId = getColorBufferHandle(grallocHandle);
if (hostColorBufferId > 0) {
DDD("found handle %d", hostColorBufferId);
} else {
diff --git a/system/codecs/c2/store/GoldfishComponentStore.cpp b/system/codecs/c2/store/GoldfishComponentStore.cpp
index 70e9077..49c5a32 100644
--- a/system/codecs/c2/store/GoldfishComponentStore.cpp
+++ b/system/codecs/c2/store/GoldfishComponentStore.cpp
@@ -237,17 +237,20 @@
return mTraits;
}
-static bool useAndroidGoldfishComponentInstance(const char *libname) {
- // We have a property set indicating whether to use the host side codec
- // or not (ro.kernel.qemu.hwcodec.<mLibNameSuffix>).
- char propValue[PROP_VALUE_MAX];
- std::string prop = "ro.kernel.qemu.hwcodec.";
- prop.append(libname);
+// We have a property set indicating whether to use the host side codec
+// or not (ro.boot.qemu.hwcodec.<mLibNameSuffix>).
+static std::string BuildHWCodecPropName(const char *libname) {
+ using namespace std::literals::string_literals;
+ return "ro.boot.qemu.hwcodec."s + libname;
+}
- bool myret = property_get(prop.c_str(), propValue, "") > 0 &&
+static bool useAndroidGoldfishComponentInstance(const char *libname) {
+ const std::string propName = BuildHWCodecPropName(libname);
+ char propValue[PROP_VALUE_MAX];
+ bool myret = property_get(propName.c_str(), propValue, "") > 0 &&
strcmp("2", propValue) == 0;
if (myret) {
- ALOGD("%s %d found prop %s val %s", __func__, __LINE__, prop.c_str(),
+ ALOGD("%s %d found prop %s val %s", __func__, __LINE__, propName.c_str(),
propValue);
}
return myret;
diff --git a/system/codecs/omx/plugin/GoldfishOMXPlugin.cpp b/system/codecs/omx/plugin/GoldfishOMXPlugin.cpp
index 52063bd..6843381 100644
--- a/system/codecs/omx/plugin/GoldfishOMXPlugin.cpp
+++ b/system/codecs/omx/plugin/GoldfishOMXPlugin.cpp
@@ -56,32 +56,33 @@
return myret;
}
-static bool useGoogleGoldfishComponentInstance(const char* libname) {
- // We have a property set indicating whether to use the host side codec
- // or not (ro.kernel.qemu.hwcodec.<mLibNameSuffix>).
- char propValue[PROP_VALUE_MAX];
- AString prop = "ro.kernel.qemu.hwcodec.";
- prop.append(libname);
+// We have a property set indicating whether to use the host side codec
+// or not (ro.boot.qemu.hwcodec.<mLibNameSuffix>).
+static std::string BuildHWCodecPropName(const char *libname) {
+ using namespace std::literals::string_literals;
+ return "ro.boot.qemu.hwcodec."s + libname;
+}
- bool myret = property_get(prop.c_str(), propValue, "") > 0 &&
+static bool useGoogleGoldfishComponentInstance(const char* libname) {
+ const std::string propName = BuildHWCodecPropName(libname);
+ char propValue[PROP_VALUE_MAX];
+
+ bool myret = property_get(propName.c_str(), propValue, "") > 0 &&
strcmp("1", propValue) == 0;
if (myret) {
- ALOGD("%s %d found prop %s val %s", __func__, __LINE__, prop.c_str(), propValue);
+ ALOGD("%s %d found prop %s val %s", __func__, __LINE__, propName.c_str(), propValue);
}
return myret;
}
static bool useAndroidGoldfishComponentInstance(const char* libname) {
- // We have a property set indicating whether to use the host side codec
- // or not (ro.kernel.qemu.hwcodec.<mLibNameSuffix>).
+ const std::string propName = BuildHWCodecPropName(libname);
char propValue[PROP_VALUE_MAX];
- AString prop = "ro.kernel.qemu.hwcodec.";
- prop.append(libname);
- bool myret = property_get(prop.c_str(), propValue, "") > 0 &&
+ bool myret = property_get(propName.c_str(), propValue, "") > 0 &&
strcmp("2", propValue) == 0;
if (myret) {
- ALOGD("%s %d found prop %s val %s", __func__, __LINE__, prop.c_str(), propValue);
+ ALOGD("%s %d found prop %s val %s", __func__, __LINE__, propName.c_str(), propValue);
}
return myret;
}
diff --git a/system/egl/egl.cpp b/system/egl/egl.cpp
index 7136786..d72fa7f 100644
--- a/system/egl/egl.cpp
+++ b/system/egl/egl.cpp
@@ -297,14 +297,18 @@
struct app_time_metric_t {
uint64_t lastLogTime;
uint64_t lastSwapBuffersReturnTime;
- uint64_t numSamples;
+ unsigned int numSamples;
uint64_t totalAppTime;
+ uint64_t minAppTime;
+ uint64_t maxAppTime;
app_time_metric_t() :
lastLogTime(0),
lastSwapBuffersReturnTime(0),
numSamples(0),
- totalAppTime(0)
+ totalAppTime(0),
+ minAppTime(0),
+ maxAppTime(0)
{
}
@@ -312,6 +316,10 @@
lastSwapBuffersReturnTime = currGuestTimeNs();
}
+ static float ns2ms(uint64_t ns) {
+ return (float)ns / 1000000.0;
+ }
+
void onQueueBufferReturn() {
if(lastSwapBuffersReturnTime == 0) {
// First swapBuffers call, or last call failed.
@@ -320,6 +328,14 @@
uint64_t now = currGuestTimeNs();
uint64_t appTime = now - lastSwapBuffersReturnTime;
+ if(numSamples == 0) {
+ minAppTime = appTime;
+ maxAppTime = appTime;
+ }
+ else {
+ minAppTime = fmin(minAppTime, appTime);
+ maxAppTime = fmax(maxAppTime, appTime);
+ }
totalAppTime += appTime;
numSamples++;
// Reset so we don't record a bad sample if swapBuffers fails
@@ -332,9 +348,13 @@
// Log/reset once every second
if(now - lastLogTime > 1000000000) {
- float averageAppTimeMs = (float)totalAppTime / 1000000.0 / numSamples;
- ALOGD("average app time: %0.2f ms (n=%llu)", averageAppTimeMs, (unsigned long long)numSamples);
+ float avgMs = ns2ms(totalAppTime) / numSamples;
+ float minMs = ns2ms(minAppTime);
+ float maxMs = ns2ms(maxAppTime);
+ ALOGD("app_time_stats: avg=%0.2fms min=%0.2fms max=%0.2fms count=%u", avgMs, minMs, maxMs, numSamples);
totalAppTime = 0;
+ minAppTime = 0;
+ maxAppTime = 0;
numSamples = 0;
lastLogTime = now;
}
@@ -1196,6 +1216,7 @@
}
int attribs_size = 0;
+ EGLint backup_attribs[1];
if (attrib_list) {
const EGLint * attrib_p = attrib_list;
while (attrib_p[0] != EGL_NONE) {
@@ -1203,6 +1224,10 @@
attrib_p += 2;
}
attribs_size++; //for the terminating EGL_NONE
+ } else {
+ attribs_size = 1;
+ backup_attribs[0] = EGL_NONE;
+ attrib_list = backup_attribs;
}
// API 19 passes EGL_SWAP_BEHAVIOR_PRESERVED_BIT to surface type,
@@ -1228,7 +1253,7 @@
attribs_size * sizeof(EGLint), (uint32_t*)tempConfigs, config_size);
if (local_attrib_list) delete [] local_attrib_list;
- if (*num_config <= 0) {
+ if (*num_config < 0) {
EGLint err = -(*num_config);
*num_config = 0;
switch (err) {
@@ -2255,6 +2280,8 @@
image->dpy = dpy;
image->target = target;
image->native_buffer = native_buffer;
+ image->width = native_buffer->width;
+ image->height = native_buffer->width;
return (EGLImageKHR)image;
}
@@ -2271,6 +2298,8 @@
image->dpy = dpy;
image->target = target;
image->host_egl_image = img;
+ image->width = context->getClientState()->queryTexWidth(0, texture);
+ image->height = context->getClientState()->queryTexHeight(0, texture);
return (EGLImageKHR)image;
}
@@ -2356,17 +2385,17 @@
// Validate and input attribs
for (int i = 0; i < num_actual_attribs; i += 2) {
- if (attrib_list[i] == EGL_SYNC_TYPE_KHR) {
- DPRINT("ERROR: attrib key = EGL_SYNC_TYPE_KHR");
- }
- if (attrib_list[i] == EGL_SYNC_STATUS_KHR) {
- DPRINT("ERROR: attrib key = EGL_SYNC_STATUS_KHR");
- }
- if (attrib_list[i] == EGL_SYNC_CONDITION_KHR) {
- DPRINT("ERROR: attrib key = EGL_SYNC_CONDITION_KHR");
- }
EGLint attrib_key = attrib_list[i];
EGLint attrib_val = attrib_list[i + 1];
+ switch (attrib_key) {
+ case EGL_SYNC_TYPE_KHR:
+ case EGL_SYNC_STATUS_KHR:
+ case EGL_SYNC_CONDITION_KHR:
+ case EGL_SYNC_NATIVE_FENCE_FD_ANDROID:
+ break;
+ default:
+ setErrorReturn(EGL_BAD_ATTRIBUTE, EGL_NO_SYNC_KHR);
+ }
if (attrib_key == EGL_SYNC_NATIVE_FENCE_FD_ANDROID) {
if (attrib_val != EGL_NO_NATIVE_FENCE_FD_ANDROID) {
inputFenceFd = attrib_val;
@@ -2435,8 +2464,8 @@
(void)dpy;
if (!eglsync) {
- DPRINT("WARNING: null sync object")
- return EGL_TRUE;
+ ALOGE("%s: null sync object!", __FUNCTION__);
+ setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
}
EGLSync_t* sync = static_cast<EGLSync_t*>(eglsync);
@@ -2467,8 +2496,8 @@
(void)dpy;
if (!eglsync) {
- DPRINT("WARNING: null sync object");
- return EGL_CONDITION_SATISFIED_KHR;
+ ALOGE("%s: null sync object!", __FUNCTION__);
+ setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
}
EGLSync_t* sync = (EGLSync_t*)eglsync;
@@ -2507,6 +2536,14 @@
EGLSync_t* sync = (EGLSync_t*)eglsync;
+ if (!sync) {
+ setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
+ }
+
+ if (!value) {
+ setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
+ }
+
switch (attribute) {
case EGL_SYNC_TYPE_KHR:
*value = sync->type;
@@ -2554,12 +2591,12 @@
if (!eglsync) {
ALOGE("%s: null sync object!", __FUNCTION__);
- return EGL_FALSE;
+ setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
}
if (flags) {
ALOGE("%s: flags must be 0, got 0x%x", __FUNCTION__, flags);
- return EGL_FALSE;
+ setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
}
DEFINE_HOST_CONNECTION;
diff --git a/system/gralloc/gralloc_old.cpp b/system/gralloc/gralloc_old.cpp
index b8f610b..2cae482 100644
--- a/system/gralloc/gralloc_old.cpp
+++ b/system/gralloc/gralloc_old.cpp
@@ -1587,7 +1587,7 @@
// qemu.gles=0 -> no GLES 2.x support (only 1.x through software).
// qemu.gles=1 -> host-side GPU emulation through EmuGL
// qemu.gles=2 -> guest-side GPU emulation.
- property_get("ro.kernel.qemu.gles", prop, "999");
+ property_get("ro.boot.qemu.gles", prop, "999");
bool useFallback = false;
switch (atoi(prop)) {
diff --git a/system/hals/allocator3.cpp b/system/hals/allocator3.cpp
index c91bafd..5c103a5 100644
--- a/system/hals/allocator3.cpp
+++ b/system/hals/allocator3.cpp
@@ -323,6 +323,12 @@
return false;
}
+ // b/186585177
+ if ((usage & (BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK)) &&
+ (0 == (usage & ~(BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK)))) {
+ return false;
+ }
+
return ((usage & BufferUsage::GPU_DATA_BUFFER)
|| (format != PixelFormat::BLOB &&
format != PixelFormat::RAW16 &&
diff --git a/system/hals/mapper3.cpp b/system/hals/mapper3.cpp
index f2116fe..6903f9b 100644
--- a/system/hals/mapper3.cpp
+++ b/system/hals/mapper3.cpp
@@ -393,7 +393,8 @@
// camera delivers bits to the buffer directly and does not require
// an explicit read.
- if (usageSwRead && !usageHwCamera) {
+ const bool cbReadable = cb.usage & BufferUsage::CPU_READ_MASK;
+ if (usageSwRead && !usageHwCamera && cbReadable) {
if (gralloc_is_yuv_format(cb.format)) {
if (rcEnc->hasYUVCache()) {
uint32_t bufferSize;
diff --git a/system/hwc2/Android.mk b/system/hwc2/Android.mk
index e8f53f9..4d207ff 100644
--- a/system/hwc2/Android.mk
+++ b/system/hwc2/Android.mk
@@ -19,16 +19,25 @@
include $(CLEAR_VARS)
LOCAL_VENDOR_MODULE := true
emulator_hwcomposer_shared_libraries := \
- liblog \
- libutils \
- libcutils \
- libdrm \
+ android.hardware.graphics.mapper@2.0 \
+ android.hardware.graphics.mapper@4.0 \
+ libbase \
libEGL \
- libutils \
+ libcutils \
+ libcuttlefish_device_config \
+ libcuttlefish_device_config_proto \
+ libcuttlefish_utils \
+ libcuttlefish_fs \
+ libdrm \
+ libgralloctypes \
libhardware \
+ libhidlbase \
+ libjpeg \
+ liblog \
libsync \
libui \
- android.hardware.graphics.mapper@2.0 \
+ libutils \
+ libutils \
emulator_hwcomposer_cflags += \
-DLOG_TAG=\"hwc2\" \
@@ -36,23 +45,32 @@
-DANDROID_BASE_UNIQUE_FD_DISABLE_IMPLICIT_CONVERSION
emulator_hwcomposer_c_includes += \
+ device/generic/goldfish-opengl/host/include/libOpenglRender \
+ device/generic/goldfish-opengl/android-emu \
+ device/generic/goldfish-opengl/shared/OpenglCodecCommon \
+ device/generic/goldfish-opengl/system/OpenglSystemCommon \
+ device/generic/goldfish-opengl/system/include \
+ device/generic/goldfish-opengl/system/renderControl_enc \
+ external/libdrm \
system/core/libsync \
system/core/libsync/include \
- device/generic/goldfish-opengl/system/include \
- device/generic/goldfish-opengl/system/OpenglSystemCommon \
- device/generic/goldfish-opengl/host/include/libOpenglRender \
- device/generic/goldfish-opengl/shared/OpenglCodecCommon \
- device/generic/goldfish-opengl/system/renderControl_enc \
- external/libdrm
emulator_hwcomposer_relative_path := hw
emulator_hwcomposer2_src_files := \
- EmuHWC2.cpp
+ Device.cpp \
+ Display.cpp \
+ Drm.cpp \
+ DrmPresenter.cpp \
+ Gralloc.cpp \
+ GuestComposer.cpp \
+ HostComposer.cpp \
+ Layer.cpp \
include $(CLEAR_VARS)
LOCAL_VENDOR_MODULE := true
+LOCAL_STATIC_LIBRARIES := libyuv_static
LOCAL_SHARED_LIBRARIES := $(emulator_hwcomposer_shared_libraries)
LOCAL_SHARED_LIBRARIES += libOpenglSystemCommon lib_renderControl_enc
LOCAL_SHARED_LIBRARIES += libui
@@ -82,4 +100,7 @@
LOCAL_C_INCLUDES += external/drm_hwcomposer
LOCAL_C_INCLUDES += external/minigbm/cros_gralloc
LOCAL_MODULE := emulatorDrmTest
+LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
+LOCAL_LICENSE_CONDITIONS := notice
+LOCAL_NOTICE_FILE := $(LOCAL_PATH)/../../LICENSE
include $(BUILD_EXECUTABLE)
diff --git a/system/hwc2/Common.h b/system/hwc2/Common.h
new file mode 100644
index 0000000..949708d
--- /dev/null
+++ b/system/hwc2/Common.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2021 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_COMMON_H
+#define ANDROID_HWC_COMMON_H
+
+#undef LOG_TAG
+#define LOG_TAG "RanchuHwc"
+
+#include <android-base/logging.h>
+#include <inttypes.h>
+#include <log/log.h>
+
+// Uncomment to enable additional debug logging.
+//#define DEBUG_RANCHU_HWC
+
+#if defined(DEBUG_RANCHU_HWC)
+#define DEBUG_LOG ALOGE
+#else
+#define DEBUG_LOG(...) ((void)0)
+#endif
+
+#define HWC2_INCLUDE_STRINGIFICATION
+#define HWC2_USE_CPP11
+#include <hardware/hwcomposer2.h>
+#undef HWC2_INCLUDE_STRINGIFICATION
+#undef HWC2_USE_CPP11
+
+#endif
diff --git a/system/hwc2/Composer.h b/system/hwc2/Composer.h
new file mode 100644
index 0000000..fdbb6b0
--- /dev/null
+++ b/system/hwc2/Composer.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2021 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_COMPOSER_H
+#define ANDROID_HWC_COMPOSER_H
+
+#include <functional>
+#include <unordered_map>
+#include <vector>
+
+#include "Common.h"
+
+namespace android {
+class Device;
+class Display;
+
+class Composer {
+ public:
+ virtual ~Composer() {}
+
+ 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*/)>;
+
+ virtual HWC2::Error init(const HotplugCallback& cb) = 0;
+
+ using AddDisplayToDeviceFunction =
+ std::function<HWC2::Error(std::unique_ptr<Display>)>;
+
+ // Queries Cuttlefish/Goldfish/System configurations and creates displays
+ // for the given Device.
+ virtual HWC2::Error createDisplays(
+ Device* device,
+ const AddDisplayToDeviceFunction& addDisplayToDeviceFn) = 0;
+
+ virtual HWC2::Error createDisplay(
+ Device* device, uint32_t displayId, uint32_t width, uint32_t height,
+ uint32_t dpiX, uint32_t dpiY, uint32_t refreshRateHz,
+ const AddDisplayToDeviceFunction& addDisplayToDeviceFn) = 0;
+
+ virtual HWC2::Error onDisplayDestroy(Display* display) = 0;
+
+ virtual HWC2::Error onDisplayClientTargetSet(Display* display) = 0;
+
+ // Determines if this composer can compose the given layers and requests
+ // changes for layers that can't not be composed.
+ virtual HWC2::Error validateDisplay(
+ Display* display, std::unordered_map<hwc2_layer_t, HWC2::Composition>*
+ outLayerCompositionChanges) = 0;
+
+ // Performs the actual composition of layers and presents the composed result
+ // to the display.
+ virtual HWC2::Error presentDisplay(Display* display,
+ int32_t* outPresentFence) = 0;
+};
+
+} // namespace android
+
+#endif
diff --git a/system/hwc2/Device.cpp b/system/hwc2/Device.cpp
new file mode 100644
index 0000000..24df956
--- /dev/null
+++ b/system/hwc2/Device.cpp
@@ -0,0 +1,589 @@
+/*
+ * Copyright 2021 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 "Device.h"
+
+#include <android-base/properties.h>
+
+#include "GuestComposer.h"
+#include "HostComposer.h"
+
+namespace android {
+namespace {
+
+template <typename PFN, typename T>
+static hwc2_function_pointer_t asFP(T function) {
+ static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
+ return reinterpret_cast<hwc2_function_pointer_t>(function);
+}
+
+static int CloseHook(hw_device_t* dev) {
+ Device* device = Device::fromDevice(dev);
+ delete device;
+ return 0;
+}
+
+bool IsCuttlefish() {
+ return android::base::GetProperty("ro.hardware.vulkan", "") == "pastel";
+}
+
+} // namespace
+
+Device::Device() {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ common.tag = HARDWARE_DEVICE_TAG;
+ common.version = HWC_DEVICE_API_VERSION_2_0;
+ common.close = CloseHook;
+ hwc2_device_t::getCapabilities = getCapabilitiesHook;
+ hwc2_device_t::getFunction = getFunctionHook;
+}
+
+HWC2::Error Device::init() {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ if (IsCuttlefish()) {
+ mComposer = std::make_unique<GuestComposer>();
+ } else {
+ mComposer = std::make_unique<HostComposer>();
+ }
+
+ HWC2::Error error = mComposer->init(
+ [this](bool connected, uint32_t id, uint32_t width, uint32_t height,
+ uint32_t dpiX, uint32_t dpiY, uint32_t refreshRate) {
+ handleHotplug(connected, id, width, height, dpiX, dpiY, refreshRate);
+ });
+
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize Composer", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+ return HWC2::Error::None;
+}
+
+Device::~Device() {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ HWC2::Error error = HWC2::Error::None;
+
+ error = destroyDisplays();
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to destroy displays", __FUNCTION__);
+ }
+}
+
+HWC2::Error Device::createDisplays() {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ std::unique_lock<std::mutex> lock(mStateMutex);
+
+ if (!mComposer) {
+ ALOGE("%s composer not initialized!", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+ auto addDisplayLockedFn = [this](std::unique_ptr<Display> display) {
+ auto displayId = display->getId();
+ DEBUG_LOG("%s: adding display:%" PRIu64, __FUNCTION__, displayId);
+ mDisplays.emplace(displayId, std::move(display));
+ return HWC2::Error::None;
+ };
+
+ HWC2::Error error = mComposer->createDisplays(this, addDisplayLockedFn);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s composer failed to create displays", __FUNCTION__);
+ return error;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Device::createDisplay(uint32_t displayId, uint32_t width,
+ uint32_t height, uint32_t dpiX, uint32_t dpiY,
+ uint32_t refreshRate) {
+ if (!mComposer) {
+ ALOGE("%s composer not initialized!", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+ auto addDisplayLockedFn = [this](std::unique_ptr<Display> display) {
+ auto displayId = display->getId();
+ DEBUG_LOG("%s: adding display:%" PRIu64, __FUNCTION__, displayId);
+ mDisplays.emplace(displayId, std::move(display));
+ return HWC2::Error::None;
+ };
+
+ HWC2::Error error =
+ mComposer->createDisplay(this, displayId, width, height, dpiX, dpiY,
+ refreshRate, addDisplayLockedFn);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s composer failed to create displays", __FUNCTION__);
+ return error;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Device::destroyDisplays() {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ std::unique_lock<std::mutex> lock(mStateMutex);
+
+ if (!mComposer) {
+ ALOGE("%s composer not initialized!", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+ for (auto& [displayId, displayPtr] : mDisplays) {
+ HWC2::Error error = mComposer->onDisplayDestroy(displayPtr.get());
+ if (error != HWC2::Error::None) {
+ ALOGE("%s composer failed to destroy displays", __FUNCTION__);
+ return error;
+ }
+
+ displayPtr.reset();
+ }
+
+ mDisplays.clear();
+
+ return HWC2::Error::None;
+}
+
+void Device::getCapabilities(uint32_t* outCount, int32_t* outCapabilities) {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ if (outCapabilities == nullptr) {
+ *outCount = mCapabilities.size();
+ return;
+ }
+
+ auto capabilityIter = mCapabilities.cbegin();
+ for (size_t i = 0; i < *outCount; ++i) {
+ if (capabilityIter == mCapabilities.cend()) {
+ return;
+ }
+ outCapabilities[i] = static_cast<int32_t>(*capabilityIter);
+ ++capabilityIter;
+ }
+}
+
+/*static*/
+void Device::getCapabilitiesHook(hwc2_device_t* dev, uint32_t* outCount,
+ int32_t* outCapabilities) {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ Device* device = Device::fromDevice(dev);
+ device->getCapabilities(outCount, outCapabilities);
+}
+
+hwc2_function_pointer_t Device::getFunction(int32_t desc) {
+ const auto func = static_cast<HWC2::FunctionDescriptor>(desc);
+ const auto funcString = to_string(func);
+ DEBUG_LOG("%s(%s)", __FUNCTION__, funcString.c_str());
+
+ switch (func) {
+ // Device functions.
+ case HWC2::FunctionDescriptor::CreateVirtualDisplay:
+ return asFP<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
+ DeviceHook<int32_t, decltype(&Device::createVirtualDisplay),
+ &Device::createVirtualDisplay, uint32_t, uint32_t,
+ int32_t*, hwc2_display_t*>);
+ case HWC2::FunctionDescriptor::DestroyVirtualDisplay:
+ return asFP<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
+ DeviceHook<int32_t, decltype(&Device::destroyVirtualDisplay),
+ &Device::destroyVirtualDisplay, hwc2_display_t>);
+ case HWC2::FunctionDescriptor::Dump:
+ return asFP<HWC2_PFN_DUMP>(DeviceHook<void, decltype(&Device::dump),
+ &Device::dump, uint32_t*, char*>);
+ case HWC2::FunctionDescriptor::GetMaxVirtualDisplayCount:
+ return asFP<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
+ DeviceHook<uint32_t, decltype(&Device::getMaxVirtualDisplayCount),
+ &Device::getMaxVirtualDisplayCount>);
+ case HWC2::FunctionDescriptor::RegisterCallback:
+ return asFP<HWC2_PFN_REGISTER_CALLBACK>(
+ DeviceHook<int32_t, decltype(&Device::registerCallback),
+ &Device::registerCallback, int32_t, hwc2_callback_data_t,
+ hwc2_function_pointer_t>);
+
+ // Display functions
+ case HWC2::FunctionDescriptor::AcceptDisplayChanges:
+ return asFP<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
+ displayHook<decltype(&Display::acceptChanges),
+ &Display::acceptChanges>);
+ case HWC2::FunctionDescriptor::CreateLayer:
+ return asFP<HWC2_PFN_CREATE_LAYER>(
+ displayHook<decltype(&Display::createLayer), &Display::createLayer,
+ hwc2_layer_t*>);
+ case HWC2::FunctionDescriptor::DestroyLayer:
+ return asFP<HWC2_PFN_DESTROY_LAYER>(
+ displayHook<decltype(&Display::destroyLayer), &Display::destroyLayer,
+ hwc2_layer_t>);
+ case HWC2::FunctionDescriptor::GetActiveConfig:
+ return asFP<HWC2_PFN_GET_ACTIVE_CONFIG>(
+ displayHook<decltype(&Display::getActiveConfig),
+ &Display::getActiveConfig, hwc2_config_t*>);
+ case HWC2::FunctionDescriptor::GetChangedCompositionTypes:
+ return asFP<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
+ displayHook<decltype(&Display::getChangedCompositionTypes),
+ &Display::getChangedCompositionTypes, uint32_t*,
+ hwc2_layer_t*, int32_t*>);
+ case HWC2::FunctionDescriptor::GetColorModes:
+ return asFP<HWC2_PFN_GET_COLOR_MODES>(
+ displayHook<decltype(&Display::getColorModes),
+ &Display::getColorModes, uint32_t*, int32_t*>);
+ case HWC2::FunctionDescriptor::GetDisplayAttribute:
+ return asFP<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(
+ displayHook<decltype(&Display::getDisplayAttribute),
+ &Display::getDisplayAttribute, hwc2_config_t, int32_t,
+ int32_t*>);
+ case HWC2::FunctionDescriptor::GetDisplayConfigs:
+ return asFP<HWC2_PFN_GET_DISPLAY_CONFIGS>(
+ displayHook<decltype(&Display::getConfigs), &Display::getConfigs,
+ uint32_t*, hwc2_config_t*>);
+ case HWC2::FunctionDescriptor::GetDisplayName:
+ return asFP<HWC2_PFN_GET_DISPLAY_NAME>(
+ displayHook<decltype(&Display::getName), &Display::getName, uint32_t*,
+ char*>);
+ case HWC2::FunctionDescriptor::GetDisplayRequests:
+ return asFP<HWC2_PFN_GET_DISPLAY_REQUESTS>(
+ displayHook<decltype(&Display::getRequests), &Display::getRequests,
+ int32_t*, uint32_t*, hwc2_layer_t*, int32_t*>);
+ case HWC2::FunctionDescriptor::GetDisplayType:
+ return asFP<HWC2_PFN_GET_DISPLAY_TYPE>(
+ displayHook<decltype(&Display::getType), &Display::getType,
+ int32_t*>);
+ case HWC2::FunctionDescriptor::GetDozeSupport:
+ return asFP<HWC2_PFN_GET_DOZE_SUPPORT>(
+ displayHook<decltype(&Display::getDozeSupport),
+ &Display::getDozeSupport, int32_t*>);
+ case HWC2::FunctionDescriptor::GetHdrCapabilities:
+ return asFP<HWC2_PFN_GET_HDR_CAPABILITIES>(
+ displayHook<decltype(&Display::getHdrCapabilities),
+ &Display::getHdrCapabilities, uint32_t*, int32_t*, float*,
+ float*, float*>);
+ case HWC2::FunctionDescriptor::GetReleaseFences:
+ return asFP<HWC2_PFN_GET_RELEASE_FENCES>(
+ displayHook<decltype(&Display::getReleaseFences),
+ &Display::getReleaseFences, uint32_t*, hwc2_layer_t*,
+ int32_t*>);
+ case HWC2::FunctionDescriptor::PresentDisplay:
+ return asFP<HWC2_PFN_PRESENT_DISPLAY>(
+ displayHook<decltype(&Display::present), &Display::present,
+ int32_t*>);
+ case HWC2::FunctionDescriptor::SetActiveConfig:
+ return asFP<HWC2_PFN_SET_ACTIVE_CONFIG>(
+ displayHook<decltype(&Display::setActiveConfig),
+ &Display::setActiveConfig, hwc2_config_t>);
+ case HWC2::FunctionDescriptor::SetClientTarget:
+ return asFP<HWC2_PFN_SET_CLIENT_TARGET>(
+ displayHook<decltype(&Display::setClientTarget),
+ &Display::setClientTarget, buffer_handle_t, int32_t,
+ int32_t, hwc_region_t>);
+ case HWC2::FunctionDescriptor::SetColorMode:
+ return asFP<HWC2_PFN_SET_COLOR_MODE>(
+ displayHook<decltype(&Display::setColorMode), &Display::setColorMode,
+ int32_t>);
+ case HWC2::FunctionDescriptor::SetColorTransform:
+ return asFP<HWC2_PFN_SET_COLOR_TRANSFORM>(
+ displayHook<decltype(&Display::setColorTransform),
+ &Display::setColorTransform, const float*, int32_t>);
+ case HWC2::FunctionDescriptor::SetOutputBuffer:
+ return asFP<HWC2_PFN_SET_OUTPUT_BUFFER>(
+ displayHook<decltype(&Display::setOutputBuffer),
+ &Display::setOutputBuffer, buffer_handle_t, int32_t>);
+ case HWC2::FunctionDescriptor::SetPowerMode:
+ return asFP<HWC2_PFN_SET_POWER_MODE>(
+ displayHook<decltype(&Display::setPowerMode), &Display::setPowerMode,
+ int32_t>);
+ case HWC2::FunctionDescriptor::SetVsyncEnabled:
+ return asFP<HWC2_PFN_SET_VSYNC_ENABLED>(
+ displayHook<decltype(&Display::setVsyncEnabled),
+ &Display::setVsyncEnabled, int32_t>);
+ case HWC2::FunctionDescriptor::ValidateDisplay:
+ return asFP<HWC2_PFN_VALIDATE_DISPLAY>(
+ displayHook<decltype(&Display::validate), &Display::validate,
+ uint32_t*, uint32_t*>);
+ case HWC2::FunctionDescriptor::GetClientTargetSupport:
+ return asFP<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
+ displayHook<decltype(&Display::getClientTargetSupport),
+ &Display::getClientTargetSupport, uint32_t, uint32_t,
+ int32_t, int32_t>);
+ case HWC2::FunctionDescriptor::GetDisplayIdentificationData:
+ return asFP<HWC2_PFN_GET_DISPLAY_IDENTIFICATION_DATA>(
+ displayHook<decltype(&Display::getDisplayIdentificationData),
+ &Display::getDisplayIdentificationData, uint8_t*,
+ uint32_t*, uint8_t*>);
+ case HWC2::FunctionDescriptor::GetDisplayCapabilities:
+ return asFP<HWC2_PFN_GET_DISPLAY_CAPABILITIES>(
+ displayHook<decltype(&Display::getDisplayCapabilities),
+ &Display::getDisplayCapabilities, uint32_t*, uint32_t*>);
+ case HWC2::FunctionDescriptor::GetDisplayBrightnessSupport:
+ return asFP<HWC2_PFN_GET_DISPLAY_BRIGHTNESS_SUPPORT>(
+ displayHook<decltype(&Display::getDisplayBrightnessSupport),
+ &Display::getDisplayBrightnessSupport, bool*>);
+ case HWC2::FunctionDescriptor::SetDisplayBrightness:
+ return asFP<HWC2_PFN_SET_DISPLAY_BRIGHTNESS>(
+ displayHook<decltype(&Display::setDisplayBrightness),
+ &Display::setDisplayBrightness, float>);
+
+ // Layer functions
+ case HWC2::FunctionDescriptor::SetCursorPosition:
+ return asFP<HWC2_PFN_SET_CURSOR_POSITION>(
+ layerHook<decltype(&Layer::setCursorPosition),
+ &Layer::setCursorPosition, int32_t, int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerBuffer:
+ return asFP<HWC2_PFN_SET_LAYER_BUFFER>(
+ layerHook<decltype(&Layer::setBuffer), &Layer::setBuffer,
+ buffer_handle_t, int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerSurfaceDamage:
+ return asFP<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
+ layerHook<decltype(&Layer::setSurfaceDamage),
+ &Layer::setSurfaceDamage, hwc_region_t>);
+ case HWC2::FunctionDescriptor::SetLayerBlendMode:
+ return asFP<HWC2_PFN_SET_LAYER_BLEND_MODE>(
+ layerHook<decltype(&Layer::setBlendMode), &Layer::setBlendMode,
+ int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerColor:
+ return asFP<HWC2_PFN_SET_LAYER_COLOR>(
+ layerHook<decltype(&Layer::setColor), &Layer::setColor, hwc_color_t>);
+ case HWC2::FunctionDescriptor::SetLayerCompositionType:
+ return asFP<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
+ layerHook<decltype(&Layer::setCompositionType),
+ &Layer::setCompositionType, int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerDataspace:
+ return asFP<HWC2_PFN_SET_LAYER_DATASPACE>(
+ layerHook<decltype(&Layer::setDataspace), &Layer::setDataspace,
+ int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerDisplayFrame:
+ return asFP<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
+ layerHook<decltype(&Layer::setDisplayFrame), &Layer::setDisplayFrame,
+ hwc_rect_t>);
+ case HWC2::FunctionDescriptor::SetLayerPlaneAlpha:
+ return asFP<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
+ layerHook<decltype(&Layer::setPlaneAlpha), &Layer::setPlaneAlpha,
+ float>);
+ case HWC2::FunctionDescriptor::SetLayerSidebandStream:
+ return asFP<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(
+ layerHook<decltype(&Layer::setSidebandStream),
+ &Layer::setSidebandStream, const native_handle_t*>);
+ case HWC2::FunctionDescriptor::SetLayerSourceCrop:
+ return asFP<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
+ layerHook<decltype(&Layer::setSourceCrop), &Layer::setSourceCrop,
+ hwc_frect_t>);
+ case HWC2::FunctionDescriptor::SetLayerTransform:
+ return asFP<HWC2_PFN_SET_LAYER_TRANSFORM>(
+ layerHook<decltype(&Layer::setTransform), &Layer::setTransform,
+ int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerVisibleRegion:
+ return asFP<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
+ layerHook<decltype(&Layer::setVisibleRegion),
+ &Layer::setVisibleRegion, hwc_region_t>);
+ case HWC2::FunctionDescriptor::SetLayerZOrder:
+ return asFP<HWC2_PFN_SET_LAYER_Z_ORDER>(
+ displayHook<decltype(&Display::updateLayerZ), &Display::updateLayerZ,
+ hwc2_layer_t, uint32_t>);
+
+ default:
+ ALOGE("GetFunction: Unknown function descriptor: %d",
+ static_cast<int32_t>(desc));
+ return nullptr;
+ }
+}
+
+/*static*/
+hwc2_function_pointer_t Device::getFunctionHook(hwc2_device_t* dev,
+ int32_t desc) {
+ Device* device = Device::fromDevice(dev);
+ return device->getFunction(desc);
+}
+
+// Device functions
+
+HWC2::Error Device::createVirtualDisplay(uint32_t /*width*/,
+ uint32_t /*height*/,
+ int32_t* /*format*/,
+ hwc2_display_t* /*outDisplay*/) {
+ DEBUG_LOG("%s", __FUNCTION__);
+ // TODO: VirtualDisplay support
+ return HWC2::Error::None;
+}
+
+HWC2::Error Device::destroyVirtualDisplay(hwc2_display_t /*displayId*/) {
+ DEBUG_LOG("%s", __FUNCTION__);
+ // TODO: VirtualDisplay support
+ return HWC2::Error::None;
+}
+
+void Device::dump(uint32_t* /*outSize*/, char* /*outBuffer*/) {
+ DEBUG_LOG("%s", __FUNCTION__);
+ // TODO:
+ return;
+}
+
+uint32_t Device::getMaxVirtualDisplayCount() {
+ DEBUG_LOG("%s", __FUNCTION__);
+ // TODO: VirtualDisplay support
+ return 0;
+}
+
+static bool IsHandledCallback(HWC2::Callback descriptor) {
+ switch (descriptor) {
+ case HWC2::Callback::Hotplug: {
+ return true;
+ }
+ case HWC2::Callback::Refresh: {
+ return true;
+ }
+ case HWC2::Callback::Vsync: {
+ return true;
+ }
+ case HWC2::Callback::Vsync_2_4: {
+ return false;
+ }
+ case HWC2::Callback::VsyncPeriodTimingChanged: {
+ return false;
+ }
+ case HWC2::Callback::Invalid: {
+ return false;
+ }
+ case HWC2::Callback::SeamlessPossible: {
+ return false;
+ }
+ }
+ return false;
+}
+
+HWC2::Error Device::registerCallback(int32_t desc,
+ hwc2_callback_data_t callbackData,
+ hwc2_function_pointer_t pointer) {
+ const auto callbackType = static_cast<HWC2::Callback>(desc);
+ const auto callbackTypeString = to_string(callbackType);
+ DEBUG_LOG("%s callback %s", __FUNCTION__, callbackTypeString.c_str());
+
+ if (!IsHandledCallback(callbackType)) {
+ ALOGE("%s unhandled callback: %s", __FUNCTION__,
+ callbackTypeString.c_str());
+ return HWC2::Error::BadParameter;
+ }
+
+ std::unique_lock<std::mutex> lock(mStateMutex);
+
+ if (pointer != nullptr) {
+ mCallbacks[callbackType] = {callbackData, pointer};
+ } else {
+ mCallbacks.erase(callbackType);
+ return HWC2::Error::None;
+ }
+
+ if (callbackType == HWC2::Callback::Hotplug) {
+ // Callback without the state lock held
+ lock.unlock();
+ auto hotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(pointer);
+ auto hotplugConnect = static_cast<int32_t>(HWC2::Connection::Connected);
+ for (const auto& [displayId, display] : mDisplays) {
+ ALOGI("%s hotplug connecting display:%" PRIu64, __FUNCTION__, displayId);
+ hotplug(callbackData, displayId, hotplugConnect);
+ }
+ }
+
+ return HWC2::Error::None;
+}
+
+bool Device::handleHotplug(bool connected, uint32_t id, uint32_t width,
+ uint32_t height, uint32_t dpiX, uint32_t dpiY,
+ uint32_t refreshRate) {
+ std::unique_lock<std::mutex> lock(mStateMutex);
+ if (mCallbacks[HWC2::Callback::Hotplug].pointer == nullptr) {
+ return false;
+ }
+ auto hotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(
+ mCallbacks[HWC2::Callback::Hotplug].pointer);
+ auto hotplugConnect = static_cast<int32_t>(HWC2::Connection::Connected);
+ auto hotplugDisconnect = static_cast<int32_t>(HWC2::Connection::Disconnected);
+ Display* display = getDisplay(id);
+ if (display) {
+ // if existed, disconnect first
+ ALOGD("callback hotplugDisconnect display %" PRIu32, id);
+ hotplug(mCallbacks[HWC2::Callback::Hotplug].data, id, hotplugDisconnect);
+ display->lock();
+ mComposer->onDisplayDestroy(display);
+ display->unlock();
+ }
+ if (connected) {
+ createDisplay(id, width, height, dpiX, dpiY, refreshRate);
+ ALOGD("callback hotplugConnect display %" PRIu32 " width %" PRIu32
+ " height %" PRIu32 " dpiX %" PRIu32 " dpiY %" PRIu32
+ "fps %" PRIu32, id, width, height, dpiX, dpiY, refreshRate);
+ hotplug(mCallbacks[HWC2::Callback::Hotplug].data, id, hotplugConnect);
+ };
+
+ return true;
+}
+
+Display* Device::getDisplay(hwc2_display_t id) {
+ auto display = mDisplays.find(id);
+ if (display == mDisplays.end()) {
+ ALOGW("Failed to get display for id=%d", (uint32_t)id);
+ return nullptr;
+ }
+ return display->second.get();
+}
+
+static int OpenDevice(const struct hw_module_t* module, const char* name,
+ struct hw_device_t** dev) {
+ DEBUG_LOG("%s ", __FUNCTION__);
+
+ if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
+ ALOGE("Invalid module name- %s", name);
+ return -EINVAL;
+ }
+
+ std::unique_ptr<Device> device = std::make_unique<Device>();
+ HWC2::Error error = device->init();
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: failed to initialize device", __FUNCTION__);
+ return -EINVAL;
+ }
+
+ error = device->createDisplays();
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: failed to initialize device displays.", __FUNCTION__);
+ return -EINVAL;
+ }
+
+ device->common.module = const_cast<hw_module_t*>(module);
+ *dev = &device.release()->common;
+ return 0;
+}
+
+} // namespace android
+
+static struct hw_module_methods_t hwc2_module_methods = {
+ .open = android::OpenDevice,
+};
+
+hw_module_t HAL_MODULE_INFO_SYM = {
+ .tag = HARDWARE_MODULE_TAG,
+ .version_major = 2,
+ .version_minor = 3,
+ .id = HWC_HARDWARE_MODULE_ID,
+ .name = "goldfish HWC2 module",
+ .author = "The Android Open Source Project",
+ .methods = &hwc2_module_methods,
+ .dso = NULL,
+ .reserved = {0},
+};
diff --git a/system/hwc2/Device.h b/system/hwc2/Device.h
new file mode 100644
index 0000000..7c990b9
--- /dev/null
+++ b/system/hwc2/Device.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2021 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_DEVICE_H
+#define ANDROID_HWC_DEVICE_H
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "Common.h"
+#include "Composer.h"
+#include "Display.h"
+#include "Layer.h"
+
+namespace android {
+
+class Composer;
+class Display;
+
+class Device : public hwc2_device_t {
+ public:
+ static inline Device* fromDevice(hw_device_t* device) {
+ return reinterpret_cast<Device*>(device);
+ }
+
+ static inline Device* fromDevice(hwc2_device_t* device) {
+ return static_cast<Device*>(device);
+ }
+
+ Device();
+ ~Device();
+
+ HWC2::Error init();
+
+ HWC2::Error createDisplays();
+
+ HWC2::Error createDisplay(uint32_t displayId, uint32_t width, uint32_t height,
+ uint32_t dpiX, uint32_t dpiY, uint32_t refreshRate);
+
+ Display* getDisplay(hwc2_display_t displayId);
+
+ private:
+ HWC2::Error destroyDisplays();
+
+ bool handleHotplug(bool connected, uint32_t id, uint32_t width,
+ uint32_t height, uint32_t dpiX, uint32_t dpiY,
+ uint32_t refreshRate);
+
+ void getCapabilities(uint32_t* outCount, int32_t* outCapabilities);
+ static void getCapabilitiesHook(hwc2_device_t* device, uint32_t* outCount,
+ int32_t* outCapabilities);
+
+ hwc2_function_pointer_t getFunction(int32_t descriptor);
+ static hwc2_function_pointer_t getFunctionHook(hwc2_device_t* device,
+ int32_t descriptor);
+
+ // Wrapper to call a specific function on a specific device.
+ template <typename T, typename HookType, HookType func, typename... Args>
+ static T DeviceHook(hwc2_device_t* dev, Args... args) {
+ Device* device = Device::fromDevice(dev);
+ return static_cast<T>(((*device).*func)(std::forward<Args>(args)...));
+ }
+
+ // Wrapper to call a specific function on a specific display.
+ template <typename HookType, HookType func, typename... Args>
+ static int32_t displayHook(hwc2_device_t* dev, hwc2_display_t displayId,
+ Args... args) {
+ Device* device = Device::fromDevice(dev);
+
+ Display* display = device->getDisplay(displayId);
+ if (display == nullptr) {
+ return static_cast<int32_t>(HWC2::Error::BadDisplay);
+ }
+
+ return static_cast<int32_t>((display->*func)(std::forward<Args>(args)...));
+ }
+
+ // Wrapper to call a specific function on a specific layer.
+ template <typename HookType, HookType func, typename... Args>
+ static int32_t layerHook(hwc2_device_t* dev, hwc2_display_t displayId,
+ hwc2_layer_t layerId, Args... args) {
+ Device* device = Device::fromDevice(dev);
+
+ Display* display = device->getDisplay(displayId);
+ if (display == nullptr) {
+ return static_cast<int32_t>(HWC2::Error::BadDisplay);
+ }
+
+ Layer* layer = display->getLayer(layerId);
+ if (layer == nullptr) {
+ return static_cast<int32_t>(HWC2::Error::BadLayer);
+ }
+
+ return static_cast<int32_t>((layer->*func)(std::forward<Args>(args)...));
+ }
+
+ // Device functions
+ HWC2::Error createVirtualDisplay(uint32_t width, uint32_t height,
+ int32_t* format, hwc2_display_t* outDisplay);
+
+ HWC2::Error destroyVirtualDisplay(hwc2_display_t display);
+
+ void dump(uint32_t* outSize, char* outBuffer);
+
+ uint32_t getMaxVirtualDisplayCount();
+
+ HWC2::Error registerCallback(int32_t descriptor,
+ hwc2_callback_data_t callbackData,
+ hwc2_function_pointer_t pointer);
+
+ // These are potentially accessed from multiple threads, and are protected
+ // by this mutex.
+ std::mutex mStateMutex;
+
+ std::unique_ptr<Composer> mComposer;
+
+ std::unordered_set<HWC2::Capability> mCapabilities;
+
+ // For sharing Vsync callback with each displays Vsync thread.
+ friend class Display;
+
+ struct CallbackInfo {
+ hwc2_callback_data_t data;
+ hwc2_function_pointer_t pointer;
+ };
+ std::unordered_map<HWC2::Callback, CallbackInfo> mCallbacks;
+
+ std::map<hwc2_display_t, std::unique_ptr<Display>> mDisplays;
+};
+
+} // namespace android
+#endif
diff --git a/system/hwc2/Display.cpp b/system/hwc2/Display.cpp
new file mode 100644
index 0000000..d187050
--- /dev/null
+++ b/system/hwc2/Display.cpp
@@ -0,0 +1,1012 @@
+/*
+ * Copyright 2021 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 "Display.h"
+
+#include <sync/sync.h>
+
+#include <atomic>
+#include <numeric>
+
+#include "Device.h"
+
+namespace android {
+namespace {
+
+using android::hardware::graphics::common::V1_0::ColorTransform;
+
+std::atomic<hwc2_config_t> sNextConfigId{0};
+
+bool IsValidColorMode(android_color_mode_t mode) {
+ switch (mode) {
+ case HAL_COLOR_MODE_NATIVE: // Fall-through
+ case HAL_COLOR_MODE_STANDARD_BT601_625: // Fall-through
+ case HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED: // Fall-through
+ case HAL_COLOR_MODE_STANDARD_BT601_525: // Fall-through
+ case HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED: // Fall-through
+ case HAL_COLOR_MODE_STANDARD_BT709: // Fall-through
+ case HAL_COLOR_MODE_DCI_P3: // Fall-through
+ case HAL_COLOR_MODE_SRGB: // Fall-through
+ case HAL_COLOR_MODE_ADOBE_RGB: // Fall-through
+ case HAL_COLOR_MODE_DISPLAY_P3:
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool isValidPowerMode(HWC2::PowerMode mode) {
+ switch (mode) {
+ case HWC2::PowerMode::Off: // Fall-through
+ case HWC2::PowerMode::DozeSuspend: // Fall-through
+ case HWC2::PowerMode::Doze: // Fall-through
+ case HWC2::PowerMode::On:
+ return true;
+ default:
+ return false;
+ }
+}
+
+} // namespace
+
+Display::Display(Device& device, Composer* composer, hwc2_display_t id)
+ : mDevice(device),
+ mComposer(composer),
+ mId(id),
+ mVsyncThread(new VsyncThread(*this)) {}
+
+Display::~Display() {}
+
+HWC2::Error Display::init(uint32_t width, uint32_t height, uint32_t dpiX,
+ uint32_t dpiY, uint32_t refreshRateHz,
+ const std::optional<std::vector<uint8_t>>& edid) {
+ ALOGD("%s initializing display:%" PRIu64
+ " width:%d height:%d dpiX:%d dpiY:%d refreshRateHz:%d",
+ __FUNCTION__, mId, width, height, dpiX, dpiY, refreshRateHz);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ mVsyncPeriod = 1000 * 1000 * 1000 / refreshRateHz;
+ mVsyncThread->run("", ANDROID_PRIORITY_URGENT_DISPLAY);
+
+ hwc2_config_t configId = sNextConfigId++;
+
+ Config config(configId);
+ config.setAttribute(HWC2::Attribute::VsyncPeriod, mVsyncPeriod);
+ config.setAttribute(HWC2::Attribute::Width, width);
+ config.setAttribute(HWC2::Attribute::Height, height);
+ config.setAttribute(HWC2::Attribute::DpiX, dpiX * 1000);
+ config.setAttribute(HWC2::Attribute::DpiY, dpiY * 1000);
+ mConfigs.emplace(configId, config);
+
+ mActiveConfigId = configId;
+ mActiveColorMode = HAL_COLOR_MODE_NATIVE;
+ mColorModes.emplace((android_color_mode_t)HAL_COLOR_MODE_NATIVE);
+ mEdid = edid;
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::updateParameters(
+ uint32_t width, uint32_t height, uint32_t dpiX, uint32_t dpiY,
+ uint32_t refreshRateHz, const std::optional<std::vector<uint8_t>>& edid) {
+ DEBUG_LOG("%s updating display:%" PRIu64
+ " width:%d height:%d dpiX:%d dpiY:%d refreshRateHz:%d",
+ __FUNCTION__, mId, width, height, dpiX, dpiY, refreshRateHz);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ mVsyncPeriod = 1000 * 1000 * 1000 / refreshRateHz;
+
+ auto it = mConfigs.find(*mActiveConfigId);
+ if (it == mConfigs.end()) {
+ ALOGE("%s: failed to find config %" PRIu32, __func__, *mActiveConfigId);
+ return HWC2::Error::NoResources;
+ }
+ it->second.setAttribute(HWC2::Attribute::VsyncPeriod, mVsyncPeriod);
+ it->second.setAttribute(HWC2::Attribute::Width, width);
+ it->second.setAttribute(HWC2::Attribute::Height, height);
+ it->second.setAttribute(HWC2::Attribute::DpiX, dpiX * 1000);
+ it->second.setAttribute(HWC2::Attribute::DpiY, dpiY * 1000);
+
+ mEdid = edid;
+
+ return HWC2::Error::None;
+}
+
+Layer* Display::getLayer(hwc2_layer_t layerId) {
+ auto it = mLayers.find(layerId);
+ if (it == mLayers.end()) {
+ ALOGE("%s Unknown layer:%" PRIu64, __FUNCTION__, layerId);
+ return nullptr;
+ }
+
+ return it->second.get();
+}
+
+buffer_handle_t Display::waitAndGetClientTargetBuffer() {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ int fence = mClientTarget.getFence();
+ if (fence != -1) {
+ int err = sync_wait(fence, 3000);
+ if (err < 0 && errno == ETIME) {
+ ALOGE("%s waited on fence %" PRId32 " for 3000 ms", __FUNCTION__, fence);
+ }
+ close(fence);
+ }
+
+ return mClientTarget.getBuffer();
+}
+
+HWC2::Error Display::acceptChanges() {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!mChanges) {
+ ALOGE("%s: display %" PRIu64 " failed, not validated", __FUNCTION__, mId);
+ return HWC2::Error::NotValidated;
+ }
+
+ for (auto& [layerId, layerCompositionType] : mChanges->getTypeChanges()) {
+ auto* layer = getLayer(layerId);
+ if (layer == nullptr) {
+ ALOGE("%s: display:%" PRIu64 " layer:%" PRIu64
+ " dropped before AcceptChanges?",
+ __FUNCTION__, mId, layerId);
+ continue;
+ }
+
+ layer->setCompositionTypeEnum(layerCompositionType);
+ }
+ mChanges->clearTypeChanges();
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::createLayer(hwc2_layer_t* outLayerId) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ auto layer = std::make_unique<Layer>();
+ auto layerId = layer->getId();
+ DEBUG_LOG("%s created layer:%" PRIu64, __FUNCTION__, layerId);
+
+ *outLayerId = layerId;
+
+ mLayers.emplace(layerId, std::move(layer));
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::destroyLayer(hwc2_layer_t layerId) {
+ DEBUG_LOG("%s destroy layer:%" PRIu64, __FUNCTION__, layerId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ auto it = mLayers.find(layerId);
+ if (it == mLayers.end()) {
+ ALOGE("%s display:%" PRIu64 " has no such layer:%." PRIu64, __FUNCTION__,
+ mId, layerId);
+ return HWC2::Error::BadLayer;
+ }
+
+ mOrderedLayers.erase(std::remove_if(mOrderedLayers.begin(), //
+ mOrderedLayers.end(), //
+ [layerId](Layer* layer) {
+ return layer->getId() == layerId;
+ }),
+ mOrderedLayers.end());
+
+ mLayers.erase(it);
+
+ DEBUG_LOG("%s destroyed layer:%" PRIu64, __FUNCTION__, layerId);
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getActiveConfig(hwc2_config_t* outConfig) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!mActiveConfigId) {
+ ALOGW("%s: display:%" PRIu64 " has no active config.", __FUNCTION__, mId);
+ return HWC2::Error::BadConfig;
+ }
+
+ *outConfig = *mActiveConfigId;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getDisplayAttributeEnum(hwc2_config_t configId,
+ HWC2::Attribute attribute,
+ int32_t* outValue) {
+ auto attributeString = to_string(attribute);
+ DEBUG_LOG("%s: display:%" PRIu64 " attribute:%s", __FUNCTION__, mId,
+ attributeString.c_str());
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ auto it = mConfigs.find(configId);
+ if (it == mConfigs.end()) {
+ ALOGW("%s: display:%" PRIu64 "bad config:%" PRIu32, __FUNCTION__, mId,
+ configId);
+ return HWC2::Error::BadConfig;
+ }
+
+ const Config& config = it->second;
+ *outValue = config.getAttribute(attribute);
+ DEBUG_LOG("%s: display:%" PRIu64 " attribute:%s value is %" PRIi32,
+ __FUNCTION__, mId, attributeString.c_str(), *outValue);
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getDisplayAttribute(hwc2_config_t configId,
+ int32_t attribute, int32_t* outValue) {
+ return getDisplayAttributeEnum(
+ configId, static_cast<HWC2::Attribute>(attribute), outValue);
+}
+
+HWC2::Error Display::getChangedCompositionTypes(uint32_t* outNumElements,
+ hwc2_layer_t* outLayers,
+ int32_t* outTypes) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!mChanges) {
+ ALOGE("%s: for display:%" PRIu64 " failed, display not validated",
+ __FUNCTION__, mId);
+ return HWC2::Error::NotValidated;
+ }
+
+ if ((outLayers == nullptr) || (outTypes == nullptr)) {
+ *outNumElements = mChanges->getTypeChanges().size();
+ return HWC2::Error::None;
+ }
+
+ uint32_t numWritten = 0;
+ for (const auto& element : mChanges->getTypeChanges()) {
+ if (numWritten == *outNumElements) {
+ break;
+ }
+
+ auto layerId = element.first;
+ const auto layerCompositionType = element.second;
+ const auto layerCompositionTypeString = to_string(layerCompositionType);
+ DEBUG_LOG("%s: display:%" PRIu64 " layer:%" PRIu64 " changed to %s",
+ __FUNCTION__, mId, layerId, layerCompositionTypeString.c_str());
+
+ outLayers[numWritten] = layerId;
+ outTypes[numWritten] = static_cast<int32_t>(layerCompositionType);
+ ++numWritten;
+ }
+ *outNumElements = numWritten;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getColorModes(uint32_t* outNumModes, int32_t* outModes) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!outModes) {
+ *outNumModes = mColorModes.size();
+ return HWC2::Error::None;
+ }
+
+ // we only support HAL_COLOR_MODE_NATIVE so far
+ uint32_t numModes = std::min<uint32_t>(
+ *outNumModes, static_cast<uint32_t>(mColorModes.size()));
+ std::copy_n(mColorModes.cbegin(), numModes, outModes);
+ *outNumModes = numModes;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getConfigs(uint32_t* outNumConfigs,
+ hwc2_config_t* outConfigs) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!outConfigs) {
+ *outNumConfigs = mConfigs.size();
+ return HWC2::Error::None;
+ }
+
+ uint32_t numWritten = 0;
+ for (const auto& [configId, config] : mConfigs) {
+ if (numWritten == *outNumConfigs) {
+ break;
+ }
+ outConfigs[numWritten] = configId;
+ ++numWritten;
+ }
+
+ *outNumConfigs = numWritten;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getDozeSupport(int32_t* outSupport) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ // We don't support so far
+ *outSupport = 0;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getHdrCapabilities(uint32_t* outNumTypes,
+ int32_t* /*outTypes*/,
+ float* /*outMaxLuminance*/,
+ float* /*outMaxAverageLuminance*/,
+ float* /*outMinLuminance*/) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ // We don't support so far
+ *outNumTypes = 0;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getName(uint32_t* outSize, char* outName) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!outName) {
+ *outSize = mName.size();
+ return HWC2::Error::None;
+ }
+ auto numCopied = mName.copy(outName, *outSize);
+ *outSize = numCopied;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::addReleaseFenceLocked(int32_t fence) {
+ DEBUG_LOG("%s: display:%" PRIu64 " fence:%d", __FUNCTION__, mId, fence);
+
+ mReleaseFences.push_back(fence);
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::addReleaseLayerLocked(hwc2_layer_t layerId) {
+ DEBUG_LOG("%s: display:%" PRIu64 " layer:%" PRIu64, __FUNCTION__, mId,
+ layerId);
+
+ mReleaseLayerIds.push_back(layerId);
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getReleaseFences(uint32_t* outNumElements,
+ hwc2_layer_t* outLayers,
+ int32_t* outFences) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ *outNumElements = mReleaseLayerIds.size();
+
+ if (*outNumElements && outLayers) {
+ DEBUG_LOG("%s export release layers", __FUNCTION__);
+ memcpy(outLayers, mReleaseLayerIds.data(),
+ sizeof(hwc2_layer_t) * (*outNumElements));
+ }
+
+ if (*outNumElements && outFences) {
+ DEBUG_LOG("%s export release fences", __FUNCTION__);
+ memcpy(outFences, mReleaseFences.data(),
+ sizeof(int32_t) * (*outNumElements));
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::clearReleaseFencesAndIdsLocked() {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ mReleaseLayerIds.clear();
+ mReleaseFences.clear();
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getRequests(int32_t* outDisplayRequests,
+ uint32_t* outNumElements,
+ hwc2_layer_t* outLayers,
+ int32_t* outLayerRequests) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!mChanges) {
+ return HWC2::Error::NotValidated;
+ }
+
+ if (outLayers == nullptr || outLayerRequests == nullptr) {
+ *outNumElements = mChanges->getNumLayerRequests();
+ return HWC2::Error::None;
+ }
+
+ // TODO
+ // Display requests (HWC2::DisplayRequest) are not supported so far:
+ *outDisplayRequests = 0;
+
+ uint32_t numWritten = 0;
+ for (const auto& request : mChanges->getLayerRequests()) {
+ if (numWritten == *outNumElements) {
+ break;
+ }
+ outLayers[numWritten] = request.first;
+ outLayerRequests[numWritten] = static_cast<int32_t>(request.second);
+ ++numWritten;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getType(int32_t* outType) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ *outType = (int32_t)mType;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::present(int32_t* outRetireFence) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ *outRetireFence = -1;
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!mChanges || (mChanges->getNumTypes() > 0)) {
+ ALOGE("%s: display:%" PRIu64 " failed, not validated", __FUNCTION__, mId);
+ return HWC2::Error::NotValidated;
+ }
+ mChanges.reset();
+
+ if (mComposer == nullptr) {
+ ALOGE("%s: display:%" PRIu64 " missing composer", __FUNCTION__, mId);
+ return HWC2::Error::NoResources;
+ }
+
+ HWC2::Error error = mComposer->presentDisplay(this, outRetireFence);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to present", __FUNCTION__, mId);
+ return error;
+ }
+
+ DEBUG_LOG("%s: display:%" PRIu64 " present done!", __FUNCTION__, mId);
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setActiveConfig(hwc2_config_t configId) {
+ DEBUG_LOG("%s: display:%" PRIu64 " setting active config to %" PRIu32,
+ __FUNCTION__, mId, configId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (mConfigs.find(configId) == mConfigs.end()) {
+ ALOGE("%s: display:%" PRIu64 " bad config:%" PRIu32, __FUNCTION__, mId,
+ configId);
+ return HWC2::Error::BadConfig;
+ }
+
+ mActiveConfigId = configId;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setClientTarget(buffer_handle_t target,
+ int32_t acquireFence,
+ int32_t /*dataspace*/,
+ hwc_region_t /*damage*/) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+ mClientTarget.setBuffer(target);
+ mClientTarget.setFence(acquireFence);
+ mComposer->onDisplayClientTargetSet(this);
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setColorMode(int32_t intMode) {
+ DEBUG_LOG("%s: display:%" PRIu64 " setting color mode to %" PRId32,
+ __FUNCTION__, mId, intMode);
+
+ auto mode = static_cast<android_color_mode_t>(intMode);
+ if (!IsValidColorMode(mode)) {
+ ALOGE("%s: display:%" PRIu64 " invalid color mode %" PRId32, __FUNCTION__,
+ mId, intMode);
+ return HWC2::Error::BadParameter;
+ }
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (mColorModes.count(mode) == 0) {
+ ALOGE("%s: display %" PRIu64 " mode %d not found", __FUNCTION__, mId,
+ intMode);
+ return HWC2::Error::Unsupported;
+ }
+ mActiveColorMode = mode;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setColorTransform(const float* transformMatrix,
+ int transformTypeRaw) {
+ const auto transformType = static_cast<ColorTransform>(transformTypeRaw);
+ return setColorTransformEnum(transformMatrix, transformType);
+}
+
+HWC2::Error Display::setColorTransformEnum(
+ const float* transformMatrix, ColorTransform transformType) {
+ const auto transformTypeString = toString(transformType);
+ DEBUG_LOG("%s: display:%" PRIu64 " color transform type %s", __FUNCTION__, mId,
+ transformTypeString.c_str());
+
+ if (transformType == ColorTransform::ARBITRARY_MATRIX &&
+ transformMatrix == nullptr) {
+ return HWC2::Error::BadParameter;
+ }
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (transformType == ColorTransform::IDENTITY) {
+ mColorTransform.reset();
+ } else {
+ ColorTransformWithMatrix& colorTransform = mColorTransform.emplace();
+ colorTransform.transformType = transformType;
+
+ if (transformType == ColorTransform::ARBITRARY_MATRIX) {
+ auto& colorTransformMatrix = colorTransform.transformMatrixOpt.emplace();
+ std::copy_n(transformMatrix, colorTransformMatrix.size(),
+ colorTransformMatrix.begin());
+ }
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setOutputBuffer(buffer_handle_t /*buffer*/,
+ int32_t /*releaseFence*/) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+ // TODO: for virtual display
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setPowerMode(int32_t intMode) {
+ auto mode = static_cast<HWC2::PowerMode>(intMode);
+ auto modeString = to_string(mode);
+ DEBUG_LOG("%s: display:%" PRIu64 " setting power mode to %s", __FUNCTION__,
+ mId, modeString.c_str());
+
+ if (!isValidPowerMode(mode)) {
+ return HWC2::Error::BadParameter;
+ }
+
+ if (mode == HWC2::PowerMode::Doze || mode == HWC2::PowerMode::DozeSuspend) {
+ ALOGE("%s display %" PRIu64 " power mode %s not supported", __FUNCTION__,
+ mId, modeString.c_str());
+ return HWC2::Error::Unsupported;
+ }
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ mPowerMode = mode;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setVsyncEnabled(int32_t intEnable) {
+ auto enable = static_cast<HWC2::Vsync>(intEnable);
+ auto enableString = to_string(enable);
+ DEBUG_LOG("%s: display:%" PRIu64 " setting vsync to %s", __FUNCTION__, mId,
+ enableString.c_str());
+
+ if (enable == HWC2::Vsync::Invalid) {
+ return HWC2::Error::BadParameter;
+ }
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+ DEBUG_LOG("%s: display:%" PRIu64 " setting vsync locked to %s", __FUNCTION__,
+ mId, enableString.c_str());
+
+ mVsyncEnabled = enable;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setVsyncPeriod(uint32_t period) {
+ DEBUG_LOG("%s: display:%" PRIu64 " setting vsync period to %d", __FUNCTION__,
+ mId, period);
+
+ mVsyncPeriod = period;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ mOrderedLayers.clear();
+ mOrderedLayers.reserve(mLayers.size());
+ for (auto& [_, layerPtr] : mLayers) {
+ mOrderedLayers.push_back(layerPtr.get());
+ }
+
+ std::sort(mOrderedLayers.begin(), mOrderedLayers.end(),
+ [](const Layer* layerA, const Layer* layerB) {
+ const auto zA = layerA->getZ();
+ const auto zB = layerB->getZ();
+ if (zA != zB) {
+ return zA < zB;
+ }
+ return layerA->getId() < layerB->getId();
+ });
+
+ if (!mChanges) {
+ mChanges.reset(new Changes);
+ } else {
+ ALOGE("Validate was called more than once!");
+ }
+
+ if (mComposer == nullptr) {
+ ALOGE("%s: display:%" PRIu64 " missing composer", __FUNCTION__, mId);
+ return HWC2::Error::NoResources;
+ }
+
+ std::unordered_map<hwc2_layer_t, HWC2::Composition> changes;
+
+ HWC2::Error error = mComposer->validateDisplay(this, &changes);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to validate", __FUNCTION__, mId);
+ return error;
+ }
+
+ for (const auto& [layerId, changedCompositionType] : changes) {
+ mChanges->addTypeChange(layerId, changedCompositionType);
+ }
+
+ *outNumTypes = mChanges->getNumTypes();
+ *outNumRequests = mChanges->getNumLayerRequests();
+ return *outNumTypes > 0 ? HWC2::Error::HasChanges : HWC2::Error::None;
+}
+
+HWC2::Error Display::updateLayerZ(hwc2_layer_t layerId, uint32_t z) {
+ DEBUG_LOG("%s: display:%" PRIu64 " update layer:%" PRIu64 " z:%d",
+ __FUNCTION__, mId, layerId, z);
+
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ const auto layerIt = mLayers.find(layerId);
+ if (layerIt == mLayers.end()) {
+ ALOGE("%s failed to find layer %" PRIu64, __FUNCTION__, layerId);
+ return HWC2::Error::BadLayer;
+ }
+
+ auto& layer = layerIt->second;
+ layer->setZ(z);
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getClientTargetSupport(uint32_t width, uint32_t height,
+ int32_t format, int32_t dataspace) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+ std::unique_lock<std::recursive_mutex> lock(mStateMutex);
+
+ if (!mActiveConfigId) {
+ return HWC2::Error::Unsupported;
+ }
+
+ const auto it = mConfigs.find(*mActiveConfigId);
+ if (it == mConfigs.end()) {
+ ALOGE("%s failed to find active config:%" PRIu32, __FUNCTION__,
+ *mActiveConfigId);
+ return HWC2::Error::Unsupported;
+ }
+
+ const Config& activeConfig = it->second;
+ const uint32_t activeConfigWidth =
+ static_cast<uint32_t>(activeConfig.getAttribute(HWC2::Attribute::Width));
+ const uint32_t activeConfigHeight =
+ static_cast<uint32_t>(activeConfig.getAttribute(HWC2::Attribute::Height));
+ if (width == activeConfigWidth && height == activeConfigHeight &&
+ format == HAL_PIXEL_FORMAT_RGBA_8888 &&
+ dataspace == HAL_DATASPACE_UNKNOWN) {
+ return HWC2::Error::None;
+ }
+
+ return HWC2::Error::None;
+}
+
+// thess EDIDs are carefully generated according to the EDID spec version 1.3,
+// more info can be found from the following file:
+// frameworks/native/services/surfaceflinger/DisplayHardware/DisplayIdentification.cpp
+// approved pnp ids can be found here: https://uefi.org/pnp_id_list
+// pnp id: GGL, name: EMU_display_0, last byte is checksum
+// display id is local:8141603649153536
+static const uint8_t sEDID0[] = {
+ 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1c, 0xec, 0x01, 0x00,
+ 0x01, 0x00, 0x00, 0x00, 0x1b, 0x10, 0x01, 0x03, 0x80, 0x50, 0x2d, 0x78,
+ 0x0a, 0x0d, 0xc9, 0xa0, 0x57, 0x47, 0x98, 0x27, 0x12, 0x48, 0x4c, 0x00,
+ 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38,
+ 0x2d, 0x40, 0x58, 0x2c, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0xfc, 0x00, 0x45, 0x4d, 0x55, 0x5f, 0x64, 0x69, 0x73,
+ 0x70, 0x6c, 0x61, 0x79, 0x5f, 0x30, 0x00, 0x4b};
+
+// pnp id: GGL, name: EMU_display_1
+// display id is local:8140900251843329
+static const uint8_t sEDID1[] = {
+ 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1c, 0xec, 0x01, 0x00,
+ 0x01, 0x00, 0x00, 0x00, 0x1b, 0x10, 0x01, 0x03, 0x80, 0x50, 0x2d, 0x78,
+ 0x0a, 0x0d, 0xc9, 0xa0, 0x57, 0x47, 0x98, 0x27, 0x12, 0x48, 0x4c, 0x00,
+ 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38,
+ 0x2d, 0x40, 0x58, 0x2c, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0xfc, 0x00, 0x45, 0x4d, 0x55, 0x5f, 0x64, 0x69, 0x73,
+ 0x70, 0x6c, 0x61, 0x79, 0x5f, 0x31, 0x00, 0x3b};
+
+// pnp id: GGL, name: EMU_display_2
+// display id is local:8140940453066754
+static const uint8_t sEDID2[] = {
+ 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1c, 0xec, 0x01, 0x00,
+ 0x01, 0x00, 0x00, 0x00, 0x1b, 0x10, 0x01, 0x03, 0x80, 0x50, 0x2d, 0x78,
+ 0x0a, 0x0d, 0xc9, 0xa0, 0x57, 0x47, 0x98, 0x27, 0x12, 0x48, 0x4c, 0x00,
+ 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38,
+ 0x2d, 0x40, 0x58, 0x2c, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0xfc, 0x00, 0x45, 0x4d, 0x55, 0x5f, 0x64, 0x69, 0x73,
+ 0x70, 0x6c, 0x61, 0x79, 0x5f, 0x32, 0x00, 0x49};
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
+HWC2::Error Display::getDisplayIdentificationData(uint8_t* outPort,
+ uint32_t* outDataSize,
+ uint8_t* outData) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ if (outPort == nullptr || outDataSize == nullptr) {
+ return HWC2::Error::BadParameter;
+ }
+
+ if (mEdid) {
+ if (outData) {
+ *outDataSize = std::min<uint32_t>(*outDataSize, (*mEdid).size());
+ memcpy(outData, (*mEdid).data(), *outDataSize);
+ } else {
+ *outDataSize = (*mEdid).size();
+ }
+ *outPort = mId;
+ return HWC2::Error::None;
+ }
+
+ // fallback to legacy EDID implementation
+ uint32_t len = std::min(*outDataSize, (uint32_t)ARRAY_SIZE(sEDID0));
+ if (outData != nullptr && len < (uint32_t)ARRAY_SIZE(sEDID0)) {
+ ALOGW("%s: display:%" PRIu64 " small buffer size: %u is specified",
+ __FUNCTION__, mId, len);
+ }
+ *outDataSize = ARRAY_SIZE(sEDID0);
+ switch (mId) {
+ case 0:
+ *outPort = 0;
+ if (outData) memcpy(outData, sEDID0, len);
+ break;
+
+ case 1:
+ *outPort = 1;
+ if (outData) memcpy(outData, sEDID1, len);
+ break;
+
+ case 2:
+ *outPort = 2;
+ if (outData) memcpy(outData, sEDID2, len);
+ break;
+
+ default:
+ *outPort = (uint8_t)mId;
+ if (outData) {
+ memcpy(outData, sEDID2, len);
+ uint32_t size = ARRAY_SIZE(sEDID0);
+ // change the name to EMU_display_<mID>
+ // note the 3rd char from back is the number, _0, _1, _2, etc.
+ if (len >= size - 2) outData[size - 3] = '0' + (uint8_t)mId;
+ if (len >= size) {
+ // update the last byte, which is checksum byte
+ uint8_t checksum = -(uint8_t)std::accumulate(
+ outData, outData + size - 1, static_cast<uint8_t>(0));
+ outData[size - 1] = checksum;
+ }
+ }
+ break;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getDisplayCapabilities(uint32_t* outNumCapabilities,
+ uint32_t* outCapabilities) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+ if (outNumCapabilities == nullptr) {
+ return HWC2::Error::None;
+ }
+
+ bool brightness_support = false;
+ bool doze_support = false;
+
+ uint32_t count = 1 + (doze_support ? 1 : 0) + (brightness_support ? 1 : 0);
+ int index = 0;
+ if (outCapabilities != nullptr && (*outNumCapabilities >= count)) {
+ outCapabilities[index++] =
+ HWC2_DISPLAY_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM;
+ if (doze_support) {
+ outCapabilities[index++] = HWC2_DISPLAY_CAPABILITY_DOZE;
+ }
+ if (brightness_support) {
+ outCapabilities[index++] = HWC2_DISPLAY_CAPABILITY_BRIGHTNESS;
+ }
+ }
+
+ *outNumCapabilities = count;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::getDisplayBrightnessSupport(bool* out_support) {
+ DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, mId);
+
+ *out_support = false;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Display::setDisplayBrightness(float brightness) {
+ DEBUG_LOG("%s: display:%" PRIu64 " brightness %f", __FUNCTION__, mId,
+ brightness);
+
+ ALOGW("TODO: setDisplayBrightness() is not implemented yet: brightness=%f",
+ brightness);
+ return HWC2::Error::Unsupported;
+}
+
+void Display::Config::setAttribute(HWC2::Attribute attribute, int32_t value) {
+ mAttributes[attribute] = value;
+}
+
+int32_t Display::Config::getAttribute(HWC2::Attribute attribute) const {
+ if (mAttributes.count(attribute) == 0) {
+ return -1;
+ }
+ return mAttributes.at(attribute);
+}
+
+std::string Display::Config::toString() const {
+ std::string output;
+
+ auto widthIt = mAttributes.find(HWC2::Attribute::Width);
+ if (widthIt != mAttributes.end()) {
+ output += " w:" + std::to_string(widthIt->second);
+ }
+
+ auto heightIt = mAttributes.find(HWC2::Attribute::Height);
+ if (heightIt != mAttributes.end()) {
+ output += " h:" + std::to_string(heightIt->second);
+ }
+
+ auto vsyncIt = mAttributes.find(HWC2::Attribute::VsyncPeriod);
+ if (vsyncIt != mAttributes.end()) {
+ output += " vsync:" + std::to_string(1e9 / vsyncIt->second);
+ }
+
+ auto dpiXIt = mAttributes.find(HWC2::Attribute::DpiX);
+ if (dpiXIt != mAttributes.end()) {
+ output += " dpi-x:" + std::to_string(dpiXIt->second / 1000.0f);
+ }
+
+ auto dpiYIt = mAttributes.find(HWC2::Attribute::DpiY);
+ if (dpiYIt != mAttributes.end()) {
+ output += " dpi-y:" + std::to_string(dpiYIt->second / 1000.0f);
+ }
+
+ return output;
+}
+
+// VsyncThread function
+bool Display::VsyncThread::threadLoop() {
+ struct timespec rt;
+ if (clock_gettime(CLOCK_MONOTONIC, &rt) == -1) {
+ ALOGE("%s: error in vsync thread clock_gettime: %s", __FUNCTION__,
+ strerror(errno));
+ return true;
+ }
+ const int logInterval = 60;
+ int64_t lastLogged = rt.tv_sec;
+ int sent = 0;
+ int lastSent = 0;
+ bool vsyncEnabled = false;
+
+ struct timespec wait_time;
+ wait_time.tv_sec = 0;
+ wait_time.tv_nsec = mDisplay.mVsyncPeriod;
+ const int64_t kOneRefreshNs = mDisplay.mVsyncPeriod;
+ const int64_t kOneSecondNs = 1000ULL * 1000ULL * 1000ULL;
+ int64_t lastTimeNs = -1;
+ int64_t phasedWaitNs = 0;
+ int64_t currentNs = 0;
+
+ while (true) {
+ clock_gettime(CLOCK_MONOTONIC, &rt);
+ currentNs = rt.tv_nsec + rt.tv_sec * kOneSecondNs;
+
+ if (lastTimeNs < 0) {
+ phasedWaitNs = currentNs + kOneRefreshNs;
+ } else {
+ phasedWaitNs =
+ kOneRefreshNs * ((currentNs - lastTimeNs) / kOneRefreshNs + 1) +
+ lastTimeNs;
+ }
+
+ wait_time.tv_sec = phasedWaitNs / kOneSecondNs;
+ wait_time.tv_nsec = phasedWaitNs - wait_time.tv_sec * kOneSecondNs;
+
+ int ret;
+ do {
+ ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &wait_time, NULL);
+ } while (ret == -1 && errno == EINTR);
+
+ lastTimeNs = phasedWaitNs;
+
+ std::unique_lock<std::recursive_mutex> lock(mDisplay.mStateMutex);
+ vsyncEnabled = (mDisplay.mVsyncEnabled == HWC2::Vsync::Enable);
+ lock.unlock();
+
+ if (!vsyncEnabled) {
+ continue;
+ }
+
+ lock.lock();
+ const auto& callbackInfo =
+ mDisplay.mDevice.mCallbacks[HWC2::Callback::Vsync];
+ auto vsync = reinterpret_cast<HWC2_PFN_VSYNC>(callbackInfo.pointer);
+ lock.unlock();
+
+ if (vsync) {
+ DEBUG_LOG("%s: display:%" PRIu64 " calling vsync", __FUNCTION__,
+ mDisplay.mId);
+ vsync(callbackInfo.data, mDisplay.mId, lastTimeNs);
+ }
+
+ int64_t lastSentInterval = rt.tv_sec - lastLogged;
+ if (lastSentInterval >= logInterval) {
+ DEBUG_LOG("sent %d syncs in %" PRId64 "s", sent - lastSent,
+ lastSentInterval);
+ lastLogged = rt.tv_sec;
+ lastSent = sent;
+ }
+ ++sent;
+ }
+ return false;
+}
+
+} // namespace android
diff --git a/system/hwc2/Display.h b/system/hwc2/Display.h
new file mode 100644
index 0000000..dc2439a
--- /dev/null
+++ b/system/hwc2/Display.h
@@ -0,0 +1,249 @@
+/*
+ * Copyright 2021 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_DISPLAY_H
+#define ANDROID_HWC_DISPLAY_H
+
+#include <android/hardware/graphics/common/1.0/types.h>
+#include <utils/Thread.h>
+
+#include <array>
+#include <optional>
+#include <set>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "Common.h"
+#include "Composer.h"
+#include "FencedBuffer.h"
+#include "Layer.h"
+
+namespace android {
+
+class Composer;
+class Device;
+
+struct ColorTransformWithMatrix {
+ android::hardware::graphics::common::V1_0::ColorTransform transformType;
+ std::optional<std::array<float, 16>> transformMatrixOpt;
+};
+
+class Display {
+ public:
+ Display(Device& device, Composer* composer, hwc2_display_t id);
+ ~Display();
+
+ Display(const Display& display) = delete;
+ Display& operator=(const Display& display) = delete;
+
+ Display(Display&& display) = delete;
+ Display& operator=(Display&& display) = delete;
+
+ HWC2::Error init(
+ uint32_t width, uint32_t height, uint32_t dpiX, uint32_t dpiY,
+ uint32_t refreshRateHz,
+ const std::optional<std::vector<uint8_t>>& edid = std::nullopt);
+
+ HWC2::Error updateParameters(
+ uint32_t width, uint32_t height, uint32_t dpiX, uint32_t dpiY,
+ uint32_t refreshRateHz,
+ const std::optional<std::vector<uint8_t>>& edid = std::nullopt);
+
+ hwc2_display_t getId() const { return mId; }
+
+ Layer* getLayer(hwc2_layer_t layerHandle);
+
+ FencedBuffer& getClientTarget() { return mClientTarget; }
+ buffer_handle_t waitAndGetClientTargetBuffer();
+
+ const std::vector<Layer*>& getOrderedLayers() { return mOrderedLayers; }
+
+ HWC2::Error acceptChanges();
+ HWC2::Error createLayer(hwc2_layer_t* outLayerId);
+ HWC2::Error destroyLayer(hwc2_layer_t layerId);
+ HWC2::Error getActiveConfig(hwc2_config_t* outConfigId);
+ HWC2::Error getDisplayAttribute(hwc2_config_t configId, int32_t attribute,
+ int32_t* outValue);
+ HWC2::Error getDisplayAttributeEnum(hwc2_config_t configId,
+ HWC2::Attribute attribute,
+ int32_t* outValue);
+ HWC2::Error getChangedCompositionTypes(uint32_t* outNumElements,
+ hwc2_layer_t* outLayers,
+ int32_t* outTypes);
+ HWC2::Error getColorModes(uint32_t* outNumModes, int32_t* outModes);
+ HWC2::Error getConfigs(uint32_t* outNumConfigs, hwc2_config_t* outConfigIds);
+ HWC2::Error getDozeSupport(int32_t* outSupport);
+ HWC2::Error getHdrCapabilities(uint32_t* outNumTypes, int32_t* outTypes,
+ float* outMaxLuminance,
+ float* outMaxAverageLuminance,
+ float* outMinLuminance);
+ HWC2::Error getName(uint32_t* outSize, char* outName);
+ HWC2::Error addReleaseFenceLocked(int32_t fence);
+ HWC2::Error addReleaseLayerLocked(hwc2_layer_t layerId);
+ HWC2::Error getReleaseFences(uint32_t* outNumElements,
+ hwc2_layer_t* outLayers, int32_t* outFences);
+ HWC2::Error clearReleaseFencesAndIdsLocked();
+ HWC2::Error getRequests(int32_t* outDisplayRequests, uint32_t* outNumElements,
+ hwc2_layer_t* outLayers, int32_t* outLayerRequests);
+ HWC2::Error getType(int32_t* outType);
+ HWC2::Error present(int32_t* outRetireFence);
+ HWC2::Error setActiveConfig(hwc2_config_t configId);
+ HWC2::Error setClientTarget(buffer_handle_t target, int32_t acquireFence,
+ int32_t dataspace, hwc_region_t damage);
+ HWC2::Error setColorMode(int32_t mode);
+ HWC2::Error setColorTransform(const float* matrix, int transform);
+ HWC2::Error setColorTransformEnum(const float* matrix,
+ android::hardware::graphics::common::V1_0::ColorTransform transform);
+ bool hasColorTransform() const { return mColorTransform.has_value(); }
+ ColorTransformWithMatrix getColorTransform() const { return *mColorTransform; }
+
+ HWC2::Error setOutputBuffer(buffer_handle_t buffer, int32_t releaseFence);
+ HWC2::Error setPowerMode(int32_t mode);
+ HWC2::Error setVsyncEnabled(int32_t enabled);
+ HWC2::Error setVsyncPeriod(uint32_t period);
+ HWC2::Error validate(uint32_t* outNumTypes, uint32_t* outNumRequests);
+ HWC2::Error updateLayerZ(hwc2_layer_t layerId, uint32_t z);
+ HWC2::Error getClientTargetSupport(uint32_t width, uint32_t height,
+ int32_t format, int32_t dataspace);
+ HWC2::Error getDisplayIdentificationData(uint8_t* outPort,
+ uint32_t* outDataSize,
+ uint8_t* outData);
+ HWC2::Error getDisplayCapabilities(uint32_t* outNumCapabilities,
+ uint32_t* outCapabilities);
+ HWC2::Error getDisplayBrightnessSupport(bool* out_support);
+ HWC2::Error setDisplayBrightness(float brightness);
+ void lock() { mStateMutex.lock(); }
+ void unlock() { mStateMutex.unlock(); }
+
+ private:
+ class Config {
+ public:
+ Config(hwc2_config_t configId) : mId(configId) {}
+
+ Config(const Config& display) = default;
+ Config& operator=(const Config& display) = default;
+
+ Config(Config&& display) = default;
+ Config& operator=(Config&& display) = default;
+
+ hwc2_config_t getId() const { return mId; }
+ void setId(hwc2_config_t id) { mId = id; }
+
+ int32_t getAttribute(HWC2::Attribute attribute) const;
+ void setAttribute(HWC2::Attribute attribute, int32_t value);
+
+ std::string toString() const;
+
+ private:
+ hwc2_config_t mId;
+ std::unordered_map<HWC2::Attribute, int32_t> mAttributes;
+ };
+
+ // Stores changes requested from the device upon calling prepare().
+ // Handles change request to:
+ // - Layer composition type.
+ // - Layer hints.
+ class Changes {
+ public:
+ uint32_t getNumTypes() const {
+ return static_cast<uint32_t>(mTypeChanges.size());
+ }
+
+ uint32_t getNumLayerRequests() const {
+ return static_cast<uint32_t>(mLayerRequests.size());
+ }
+
+ const std::unordered_map<hwc2_layer_t, HWC2::Composition>& getTypeChanges()
+ const {
+ return mTypeChanges;
+ }
+
+ const std::unordered_map<hwc2_layer_t, HWC2::LayerRequest>&
+ getLayerRequests() const {
+ return mLayerRequests;
+ }
+
+ void addTypeChange(hwc2_layer_t layerId, HWC2::Composition type) {
+ mTypeChanges.insert({layerId, type});
+ }
+
+ void clearTypeChanges() { mTypeChanges.clear(); }
+
+ void addLayerRequest(hwc2_layer_t layerId, HWC2::LayerRequest request) {
+ mLayerRequests.insert({layerId, request});
+ }
+
+ private:
+ std::unordered_map<hwc2_layer_t, HWC2::Composition> mTypeChanges;
+ std::unordered_map<hwc2_layer_t, HWC2::LayerRequest> mLayerRequests;
+ };
+
+ // Generate sw vsync signal
+ class VsyncThread : public Thread {
+ public:
+ VsyncThread(Display& display) : mDisplay(display) {}
+ virtual ~VsyncThread() {}
+
+ VsyncThread(const VsyncThread&) = default;
+ VsyncThread& operator=(const VsyncThread&) = default;
+
+ VsyncThread(VsyncThread&&) = default;
+ VsyncThread& operator=(VsyncThread&&) = default;
+
+ private:
+ Display& mDisplay;
+ bool threadLoop() final;
+ };
+
+ private:
+ // The state of this display should only be modified from
+ // SurfaceFlinger's main loop, with the exception of when dump is
+ // called. To prevent a bad state from crashing us during a dump
+ // call, all public calls into Display must acquire this mutex.
+ mutable std::recursive_mutex mStateMutex;
+
+ Device& mDevice;
+ Composer* mComposer = nullptr;
+ const hwc2_display_t mId;
+ std::string mName;
+ HWC2::DisplayType mType = HWC2::DisplayType::Physical;
+ HWC2::PowerMode mPowerMode = HWC2::PowerMode::Off;
+ HWC2::Vsync mVsyncEnabled = HWC2::Vsync::Invalid;
+ uint32_t mVsyncPeriod;
+ sp<VsyncThread> mVsyncThread;
+ FencedBuffer mClientTarget;
+ // Will only be non-null after the Display has been validated and
+ // before it has been presented
+ std::unique_ptr<Changes> mChanges;
+
+ std::unordered_map<hwc2_layer_t, std::unique_ptr<Layer>> mLayers;
+ // Ordered layers available after validate().
+ std::vector<Layer*> mOrderedLayers;
+
+ std::vector<hwc2_display_t> mReleaseLayerIds;
+ std::vector<int32_t> mReleaseFences;
+ std::optional<hwc2_config_t> mActiveConfigId;
+ std::unordered_map<hwc2_config_t, Config> mConfigs;
+ std::set<android_color_mode_t> mColorModes;
+ android_color_mode_t mActiveColorMode;
+ std::optional<ColorTransformWithMatrix> mColorTransform;
+ std::optional<std::vector<uint8_t>> mEdid;
+};
+
+} // namespace android
+
+#endif
diff --git a/system/hwc2/Drm.cpp b/system/hwc2/Drm.cpp
new file mode 100644
index 0000000..4b27fa2
--- /dev/null
+++ b/system/hwc2/Drm.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2020 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 "Drm.h"
+
+#include <drm_fourcc.h>
+#include <log/log.h>
+#include <system/graphics.h>
+
+namespace android {
+
+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";
+}
+
+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:
+#ifdef GRALLOC_MODULE_API_VERSION_0_2
+ 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;
+}
+
+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;
+}
+
+} // namespace android
\ No newline at end of file
diff --git a/system/hwc2/Drm.h b/system/hwc2/Drm.h
new file mode 100644
index 0000000..9bc18b3
--- /dev/null
+++ b/system/hwc2/Drm.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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_DRM_H
+#define ANDROID_HWC_DRM_H
+
+#include <cstdlib>
+
+namespace android {
+
+const char* GetDrmFormatString(uint32_t drm_format);
+
+int GetDrmFormatBytesPerPixel(uint32_t drm_format);
+
+int GetDrmFormatFromHalFormat(int hal_format);
+
+} // namespace android
+
+#endif
\ No newline at end of file
diff --git a/system/hwc2/DrmPresenter.cpp b/system/hwc2/DrmPresenter.cpp
new file mode 100644
index 0000000..4d63c58
--- /dev/null
+++ b/system/hwc2/DrmPresenter.cpp
@@ -0,0 +1,641 @@
+/*
+ * Copyright 2021 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>
+
+using android::base::guest::AutoReadLock;
+using android::base::guest::AutoWriteLock;
+using android::base::guest::ReadWriteLock;
+
+namespace android {
+
+bool DrmPresenter::init(const HotplugCallback& cb) {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ mHotplugCallback = cb;
+ mFd = android::base::unique_fd(open("/dev/dri/card0", O_RDWR | O_CLOEXEC));
+ if (mFd < 0) {
+ ALOGE("%s HWC2::Error opening DrmPresenter device: %d", __FUNCTION__,
+ errno);
+ return false;
+ }
+
+ int univRet = drmSetClientCap(mFd.get(), DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
+ if (univRet) {
+ ALOGE("%s: fail to set universal plane %d\n", __FUNCTION__, univRet);
+ return false;
+ }
+
+ int atomicRet = drmSetClientCap(mFd.get(), DRM_CLIENT_CAP_ATOMIC, 1);
+ if (atomicRet) {
+ ALOGE("%s: fail to set atomic operation %d, %d\n", __FUNCTION__, atomicRet,
+ errno);
+ return false;
+ }
+
+ {
+ AutoWriteLock lock(mStateMutex);
+ bool initDrmRet = initDrmElementsLocked();
+ if (initDrmRet) {
+ ALOGD("%s: Successfully initialized DRM backend", __FUNCTION__);
+ } else {
+ ALOGE("%s: Failed to initialize DRM backend", __FUNCTION__);
+ return false;
+ }
+ }
+
+ mDrmEventListener = sp<DrmEventListener>::make(*this);
+ if (mDrmEventListener->init()) {
+ ALOGD("%s: Successfully initialized DRM event listener", __FUNCTION__);
+ } else {
+ ALOGE("%s: Failed to initialize DRM event listener", __FUNCTION__);
+ }
+ mDrmEventListener->run("", ANDROID_PRIORITY_URGENT_DISPLAY);
+
+ return true;
+}
+
+bool DrmPresenter::initDrmElementsLocked() {
+ drmModeRes* res;
+ static const int32_t kUmPerInch = 25400;
+
+ res = drmModeGetResources(mFd.get());
+ if (res == nullptr) {
+ ALOGE("%s HWC2::Error reading drm resources: %d", __FUNCTION__, errno);
+ mFd.reset();
+ return false;
+ }
+
+ ALOGD(
+ "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.mFencePropertyId = 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;
+
+ ALOGD(
+ "%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, "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;
+ ALOGD("%s: plane %" PRIu32 " is DRM_PLANE_TYPE_OVERLAY",
+ __FUNCTION__, plane.mId);
+ break;
+ case DRM_PLANE_TYPE_PRIMARY:
+ plane.mType = type;
+ ALOGD("%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) {
+ ALOGD("%s: plane %" PRIu32 " compatible with crtc mask %" PRIu32,
+ __FUNCTION__, plane.mId, p->possible_crtcs);
+ if (mCrtcs[j].mPlaneId == -1) {
+ mCrtcs[j].mPlaneId = plane.mId;
+ ALOGD("%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;
+ }
+ ALOGD("%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();
+}
+
+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;
+}
+
+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);
+ }
+ ret = -1;
+ }
+ 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;
+}
+
+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;
+ }
+
+ 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;
+}
+
+HWC2::Error DrmPresenter::flushToDisplay(int display, hwc_drm_bo_t& bo,
+ int* outSyncFd) {
+ AutoReadLock lock(mStateMutex);
+
+ DrmConnector& connector = mConnectors[display];
+ DrmCrtc& crtc = mCrtcs[display];
+
+ HWC2::Error error = HWC2::Error::None;
+
+ *outSyncFd = -1;
+
+ 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 %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, crtc.mId, crtc.mModePropertyId,
+ connector.mModeBlobId);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, connector.mId,
+ connector.mCrtcPropertyId, crtc.mId);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+
+ crtc.mDidSetCrtc = true;
+ } else {
+ DEBUG_LOG("%s: Already set crtc\n", __FUNCTION__);
+ }
+
+ uint64_t outSyncFdUint = (uint64_t)outSyncFd;
+
+ ret = drmModeAtomicAddProperty(pset, crtc.mId, crtc.mFencePropertyId,
+ outSyncFdUint);
+ if (ret < 0) {
+ ALOGE("%s:%d: 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 HWC2::Error::NoResources;
+ }
+
+ 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);
+
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcPropertyId,
+ crtc.mId);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret =
+ drmModeAtomicAddProperty(pset, plane.mId, plane.mFbPropertyId, bo.fb_id);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcXPropertyId, 0);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcYPropertyId, 0);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcWPropertyId,
+ bo.width);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcHPropertyId,
+ bo.height);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcXPropertyId, 0);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcYPropertyId, 0);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcWPropertyId,
+ bo.width << 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);
+ if (ret < 0) {
+ ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
+ }
+
+ uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;
+ ret = drmModeAtomicCommit(mFd.get(), pset, flags, 0);
+
+ if (ret) {
+ ALOGE("%s: Atomic commit failed with %d %d\n", __FUNCTION__, ret, errno);
+ error = HWC2::Error::NoResources;
+ }
+
+ if (pset) {
+ drmModeAtomicFree(pset);
+ }
+
+ DEBUG_LOG("%s: out fence: %d\n", __FUNCTION__, *outSyncFd);
+ return error;
+}
+
+std::optional<std::vector<uint8_t>> DrmPresenter::getEdid(uint32_t id) {
+ AutoReadLock lock(mStateMutex);
+
+ if (mConnectors[id].mEdidBlobId == -1) {
+ ALOGW("%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(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;
+}
+
+HWC2::Error DrmBuffer::flushToDisplay(int display, int* outFlushDoneSyncFd) {
+ return mDrmPresenter.flushToDisplay(display, mBo, outFlushDoneSyncFd);
+}
+
+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 android
diff --git a/system/hwc2/DrmPresenter.h b/system/hwc2/DrmPresenter.h
new file mode 100644
index 0000000..7f9edb2
--- /dev/null
+++ b/system/hwc2/DrmPresenter.h
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2021 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 <include/drmhwcgralloc.h>
+#include <utils/Thread.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "Common.h"
+#include "android/base/synchronization/AndroidLock.h"
+
+namespace android {
+
+class DrmBuffer;
+class DrmPresenter;
+
+// 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;
+ DrmBuffer& operator=(const DrmBuffer&) = delete;
+
+ DrmBuffer(DrmBuffer&&) = delete;
+ DrmBuffer& operator=(DrmBuffer&&) = delete;
+
+ HWC2::Error flushToDisplay(int display, int* outFlushDoneSyncFd);
+
+ private:
+ int convertBoInfo(const native_handle_t* handle);
+
+ DrmPresenter& mDrmPresenter;
+ hwc_drm_bo_t mBo;
+};
+
+class DrmPresenter {
+ public:
+ DrmPresenter() = default;
+ ~DrmPresenter() = default;
+
+ DrmPresenter(const DrmPresenter&) = delete;
+ DrmPresenter& operator=(const DrmPresenter&) = delete;
+
+ DrmPresenter(DrmPresenter&&) = delete;
+ DrmPresenter& operator=(DrmPresenter&&) = delete;
+
+ 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*/)>;
+
+ bool init(const HotplugCallback& cb);
+
+ uint32_t refreshRate() const { return mConnectors[0].mRefreshRateAsInteger; }
+
+ HWC2::Error flushToDisplay(int display, hwc_drm_bo_t& fb, int* outSyncFd);
+
+ std::optional<std::vector<uint8_t>> getEdid(uint32_t id);
+
+ private:
+ // Grant visibility for getDrmFB and clearDrmFB to DrmBuffer.
+ friend class DrmBuffer;
+ int getDrmFB(hwc_drm_bo_t& bo);
+ int clearDrmFB(hwc_drm_bo_t& bo);
+
+ // Grant visibility for handleHotplug to DrmEventListener.
+ bool handleHotplug();
+
+ bool initDrmElementsLocked();
+ void resetDrmElementsLocked();
+
+ // Drm device.
+ android::base::unique_fd mFd;
+
+ HotplugCallback mHotplugCallback;
+
+ // Protects access to the below drm structs.
+ android::base::guest::ReadWriteLock mStateMutex;
+
+ struct DrmPlane {
+ uint32_t mId = -1;
+ uint32_t mCrtcPropertyId = -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 mFencePropertyId = -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 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 android
+
+#endif
diff --git a/system/hwc2/EmuHWC2.cpp b/system/hwc2/EmuHWC2.cpp
deleted file mode 100644
index 5faec36..0000000
--- a/system/hwc2/EmuHWC2.cpp
+++ /dev/null
@@ -1,2226 +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 "EmuHWC2.h"
-//#define LOG_NDEBUG 0
-//#define LOG_NNDEBUG 0
-#undef LOG_TAG
-#define LOG_TAG "EmuHWC2"
-
-#include <errno.h>
-#include <cutils/properties.h>
-#include <log/log.h>
-#include <sync/sync.h>
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <ui/GraphicBuffer.h>
-#include <ui/GraphicBufferAllocator.h>
-#include <ui/GraphicBufferMapper.h>
-
-#include "cros_gralloc_handle.h"
-#include "../egl/goldfish_sync.h"
-
-#include "ThreadInfo.h"
-
-#include <drm/virtgpu_drm.h>
-#include <xf86drm.h>
-#include <poll.h>
-
-#if defined(LOG_NNDEBUG) && LOG_NNDEBUG == 0
-#define ALOGVV ALOGV
-#else
-#define ALOGVV(...) ((void)0)
-#endif
-
-template <typename PFN, typename T>
-static hwc2_function_pointer_t asFP(T function)
-{
- static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
- return reinterpret_cast<hwc2_function_pointer_t>(function);
-}
-
-static std::unique_ptr<HostConnection> sHostCon;
-
-static HostConnection* createOrGetHostConnection() {
- if (!sHostCon) {
- sHostCon = HostConnection::createUnique();
- }
- return sHostCon.get();
-}
-
-#define DEFINE_AND_VALIDATE_HOST_CONNECTION \
- HostConnection *hostCon = createOrGetHostConnection(); \
- if (!hostCon) { \
- ALOGE("EmuHWC2: Failed to get host connection\n"); \
- return Error::NoResources; \
- } \
- ExtendedRCEncoderContext *rcEnc = hostCon->rcEncoder(); \
- if (!rcEnc) { \
- ALOGE("EmuHWC2: Failed to get renderControl encoder context\n"); \
- return Error::NoResources; \
- }
-
-using namespace HWC2;
-
-namespace android {
-
-EmuHWC2::EmuHWC2()
- : mStateMutex()
-{
- common.tag = HARDWARE_DEVICE_TAG;
- common.version = HWC_DEVICE_API_VERSION_2_0;
- common.close = closeHook;
- getCapabilities = getCapabilitiesHook;
- getFunction = getFunctionHook;
- populateCapabilities();
- initDisplayParameters();
-}
-
-Error EmuHWC2::initDisplayParameters() {
- DEFINE_AND_VALIDATE_HOST_CONNECTION
- hostCon->lock();
-
- mDisplayWidth = rcEnc->rcGetFBParam(rcEnc, FB_WIDTH);
- mDisplayHeight = rcEnc->rcGetFBParam(rcEnc, FB_HEIGHT);
- mDisplayDpiX = rcEnc->rcGetFBParam(rcEnc, FB_XDPI);
- mDisplayDpiY = rcEnc->rcGetFBParam(rcEnc, FB_YDPI);
-
- hostCon->unlock();
-
- return HWC2::Error::None;
-}
-
-void EmuHWC2::doGetCapabilities(uint32_t* outCount, int32_t* outCapabilities) {
- if (outCapabilities == nullptr) {
- *outCount = mCapabilities.size();
- return;
- }
-
- auto capabilityIter = mCapabilities.cbegin();
- for (size_t i = 0; i < *outCount; ++i) {
- if (capabilityIter == mCapabilities.cend()) {
- return;
- }
- outCapabilities[i] = static_cast<int32_t>(*capabilityIter);
- ++capabilityIter;
- }
-}
-
-hwc2_function_pointer_t EmuHWC2::doGetFunction(
- FunctionDescriptor descriptor) {
- switch(descriptor) {
- case FunctionDescriptor::CreateVirtualDisplay:
- return asFP<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
- createVirtualDisplayHook);
- case FunctionDescriptor::DestroyVirtualDisplay:
- return asFP<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
- destroyVirtualDisplayHook);
- case FunctionDescriptor::Dump:
- return asFP<HWC2_PFN_DUMP>(dumpHook);
- case FunctionDescriptor::GetMaxVirtualDisplayCount:
- return asFP<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
- getMaxVirtualDisplayCountHook);
- case FunctionDescriptor::RegisterCallback:
- return asFP<HWC2_PFN_REGISTER_CALLBACK>(registerCallbackHook);
-
- // Display functions
- case FunctionDescriptor::AcceptDisplayChanges:
- return asFP<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
- displayHook<decltype(&Display::acceptChanges),
- &Display::acceptChanges>);
- case FunctionDescriptor::CreateLayer:
- return asFP<HWC2_PFN_CREATE_LAYER>(
- displayHook<decltype(&Display::createLayer),
- &Display::createLayer, hwc2_layer_t*>);
- case FunctionDescriptor::DestroyLayer:
- return asFP<HWC2_PFN_DESTROY_LAYER>(
- displayHook<decltype(&Display::destroyLayer),
- &Display::destroyLayer, hwc2_layer_t>);
- case FunctionDescriptor::GetActiveConfig:
- return asFP<HWC2_PFN_GET_ACTIVE_CONFIG>(
- displayHook<decltype(&Display::getActiveConfig),
- &Display::getActiveConfig, hwc2_config_t*>);
- case FunctionDescriptor::GetChangedCompositionTypes:
- return asFP<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
- displayHook<decltype(&Display::getChangedCompositionTypes),
- &Display::getChangedCompositionTypes, uint32_t*,
- hwc2_layer_t*, int32_t*>);
- case FunctionDescriptor::GetColorModes:
- return asFP<HWC2_PFN_GET_COLOR_MODES>(
- displayHook<decltype(&Display::getColorModes),
- &Display::getColorModes, uint32_t*, int32_t*>);
- case FunctionDescriptor::GetDisplayAttribute:
- return asFP<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(
- displayHook<decltype(&Display::getDisplayAttribute),
- &Display::getDisplayAttribute, hwc2_config_t,
- int32_t, int32_t*>);
- case FunctionDescriptor::GetDisplayConfigs:
- return asFP<HWC2_PFN_GET_DISPLAY_CONFIGS>(
- displayHook<decltype(&Display::getConfigs),
- &Display::getConfigs, uint32_t*, hwc2_config_t*>);
- case FunctionDescriptor::GetDisplayName:
- return asFP<HWC2_PFN_GET_DISPLAY_NAME>(
- displayHook<decltype(&Display::getName),
- &Display::getName, uint32_t*, char*>);
- case FunctionDescriptor::GetDisplayRequests:
- return asFP<HWC2_PFN_GET_DISPLAY_REQUESTS>(
- displayHook<decltype(&Display::getRequests),
- &Display::getRequests, int32_t*, uint32_t*, hwc2_layer_t*,
- int32_t*>);
- case FunctionDescriptor::GetDisplayType:
- return asFP<HWC2_PFN_GET_DISPLAY_TYPE>(
- displayHook<decltype(&Display::getType),
- &Display::getType, int32_t*>);
- case FunctionDescriptor::GetDozeSupport:
- return asFP<HWC2_PFN_GET_DOZE_SUPPORT>(
- displayHook<decltype(&Display::getDozeSupport),
- &Display::getDozeSupport, int32_t*>);
- case FunctionDescriptor::GetHdrCapabilities:
- return asFP<HWC2_PFN_GET_HDR_CAPABILITIES>(
- displayHook<decltype(&Display::getHdrCapabilities),
- &Display::getHdrCapabilities, uint32_t*, int32_t*, float*,
- float*, float*>);
- case FunctionDescriptor::GetReleaseFences:
- return asFP<HWC2_PFN_GET_RELEASE_FENCES>(
- displayHook<decltype(&Display::getReleaseFences),
- &Display::getReleaseFences, uint32_t*, hwc2_layer_t*,
- int32_t*>);
- case FunctionDescriptor::PresentDisplay:
- return asFP<HWC2_PFN_PRESENT_DISPLAY>(
- displayHook<decltype(&Display::present),
- &Display::present, int32_t*>);
- case FunctionDescriptor::SetActiveConfig:
- return asFP<HWC2_PFN_SET_ACTIVE_CONFIG>(
- displayHook<decltype(&Display::setActiveConfig),
- &Display::setActiveConfig, hwc2_config_t>);
- case FunctionDescriptor::SetClientTarget:
- return asFP<HWC2_PFN_SET_CLIENT_TARGET>(
- displayHook<decltype(&Display::setClientTarget),
- &Display::setClientTarget, buffer_handle_t, int32_t,
- int32_t, hwc_region_t>);
- case FunctionDescriptor::SetColorMode:
- return asFP<HWC2_PFN_SET_COLOR_MODE>(
- displayHook<decltype(&Display::setColorMode),
- &Display::setColorMode, int32_t>);
- case FunctionDescriptor::SetColorTransform:
- return asFP<HWC2_PFN_SET_COLOR_TRANSFORM>(
- displayHook<decltype(&Display::setColorTransform),
- &Display::setColorTransform, const float*, int32_t>);
- case FunctionDescriptor::SetOutputBuffer:
- return asFP<HWC2_PFN_SET_OUTPUT_BUFFER>(
- displayHook<decltype(&Display::setOutputBuffer),
- &Display::setOutputBuffer, buffer_handle_t, int32_t>);
- case FunctionDescriptor::SetPowerMode:
- return asFP<HWC2_PFN_SET_POWER_MODE>(
- displayHook<decltype(&Display::setPowerMode),
- &Display::setPowerMode, int32_t>);
- case FunctionDescriptor::SetVsyncEnabled:
- return asFP<HWC2_PFN_SET_VSYNC_ENABLED>(
- displayHook<decltype(&Display::setVsyncEnabled),
- &Display::setVsyncEnabled, int32_t>);
- case FunctionDescriptor::ValidateDisplay:
- return asFP<HWC2_PFN_VALIDATE_DISPLAY>(
- displayHook<decltype(&Display::validate),
- &Display::validate, uint32_t*, uint32_t*>);
- case FunctionDescriptor::GetClientTargetSupport:
- return asFP<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
- displayHook<decltype(&Display::getClientTargetSupport),
- &Display::getClientTargetSupport, uint32_t, uint32_t,
- int32_t, int32_t>);
- // 2.3 required functions
- case FunctionDescriptor::GetDisplayIdentificationData:
- return asFP<HWC2_PFN_GET_DISPLAY_IDENTIFICATION_DATA>(
- displayHook<decltype(&Display::getDisplayIdentificationData),
- &Display::getDisplayIdentificationData, uint8_t*, uint32_t*, uint8_t*>);
- case FunctionDescriptor::GetDisplayCapabilities:
- return asFP<HWC2_PFN_GET_DISPLAY_CAPABILITIES>(
- displayHook<decltype(&Display::getDisplayCapabilities),
- &Display::getDisplayCapabilities, uint32_t*, uint32_t*>);
- case FunctionDescriptor::GetDisplayBrightnessSupport:
- return asFP<HWC2_PFN_GET_DISPLAY_BRIGHTNESS_SUPPORT>(
- displayHook<decltype(&Display::getDisplayBrightnessSupport),
- &Display::getDisplayBrightnessSupport, bool*>);
- case FunctionDescriptor::SetDisplayBrightness:
- return asFP<HWC2_PFN_SET_DISPLAY_BRIGHTNESS>(
- displayHook<decltype(&Display::setDisplayBrightness),
- &Display::setDisplayBrightness, float>);
- // Layer functions
- case FunctionDescriptor::SetCursorPosition:
- return asFP<HWC2_PFN_SET_CURSOR_POSITION>(
- layerHook<decltype(&Layer::setCursorPosition),
- &Layer::setCursorPosition, int32_t, int32_t>);
- case FunctionDescriptor::SetLayerBuffer:
- return asFP<HWC2_PFN_SET_LAYER_BUFFER>(
- layerHook<decltype(&Layer::setBuffer), &Layer::setBuffer,
- buffer_handle_t, int32_t>);
- case FunctionDescriptor::SetLayerSurfaceDamage:
- return asFP<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
- layerHook<decltype(&Layer::setSurfaceDamage),
- &Layer::setSurfaceDamage, hwc_region_t>);
-
- // Layer state functions
- case FunctionDescriptor::SetLayerBlendMode:
- return asFP<HWC2_PFN_SET_LAYER_BLEND_MODE>(
- layerHook<decltype(&Layer::setBlendMode),
- &Layer::setBlendMode, int32_t>);
- case FunctionDescriptor::SetLayerColor:
- return asFP<HWC2_PFN_SET_LAYER_COLOR>(
- layerHook<decltype(&Layer::setColor), &Layer::setColor,
- hwc_color_t>);
- case FunctionDescriptor::SetLayerCompositionType:
- return asFP<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
- layerHook<decltype(&Layer::setCompositionType),
- &Layer::setCompositionType, int32_t>);
- case FunctionDescriptor::SetLayerDataspace:
- return asFP<HWC2_PFN_SET_LAYER_DATASPACE>(
- layerHook<decltype(&Layer::setDataspace),
- &Layer::setDataspace, int32_t>);
- case FunctionDescriptor::SetLayerDisplayFrame:
- return asFP<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
- layerHook<decltype(&Layer::setDisplayFrame),
- &Layer::setDisplayFrame, hwc_rect_t>);
- case FunctionDescriptor::SetLayerPlaneAlpha:
- return asFP<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
- layerHook<decltype(&Layer::setPlaneAlpha),
- &Layer::setPlaneAlpha, float>);
- case FunctionDescriptor::SetLayerSidebandStream:
- return asFP<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(
- layerHook<decltype(&Layer::setSidebandStream),
- &Layer::setSidebandStream, const native_handle_t*>);
- case FunctionDescriptor::SetLayerSourceCrop:
- return asFP<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
- layerHook<decltype(&Layer::setSourceCrop),
- &Layer::setSourceCrop, hwc_frect_t>);
- case FunctionDescriptor::SetLayerTransform:
- return asFP<HWC2_PFN_SET_LAYER_TRANSFORM>(
- layerHook<decltype(&Layer::setTransform),
- &Layer::setTransform, int32_t>);
- case FunctionDescriptor::SetLayerVisibleRegion:
- return asFP<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
- layerHook<decltype(&Layer::setVisibleRegion),
- &Layer::setVisibleRegion, hwc_region_t>);
- case FunctionDescriptor::SetLayerZOrder:
- return asFP<HWC2_PFN_SET_LAYER_Z_ORDER>(
- displayHook<decltype(&Display::updateLayerZ),
- &Display::updateLayerZ, hwc2_layer_t, uint32_t>);
-
- default:
- ALOGE("doGetFunction: Unknown function descriptor: %d (%s)",
- static_cast<int32_t>(descriptor),
- to_string(descriptor).c_str());
- return nullptr;
- }
-}
-
-
-// Device functions
-
-Error EmuHWC2::createVirtualDisplay(uint32_t /*width*/, uint32_t /*height*/,
- int32_t* /*format*/, hwc2_display_t* /*outDisplay*/) {
- ALOGVV("%s", __FUNCTION__);
- //TODO: VirtualDisplay support
- return Error::None;
-}
-
-Error EmuHWC2::destroyVirtualDisplay(hwc2_display_t /*displayId*/) {
- ALOGVV("%s", __FUNCTION__);
- //TODO: VirtualDisplay support
- return Error::None;
-}
-
-void EmuHWC2::dump(uint32_t* /*outSize*/, char* /*outBuffer*/) {
- ALOGVV("%s", __FUNCTION__);
- //TODO:
- return;
-}
-
-uint32_t EmuHWC2::getMaxVirtualDisplayCount() {
- ALOGVV("%s", __FUNCTION__);
- //TODO: VirtualDisplay support
- return 0;
-}
-
-static bool isValid(Callback descriptor) {
- switch (descriptor) {
- case Callback::Hotplug: // Fall-through
- case Callback::Refresh: // Fall-through
- case Callback::Vsync: return true;
- default: return false;
- }
-}
-
-Error EmuHWC2::registerCallback(Callback descriptor,
- hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer) {
- ALOGVV("%s", __FUNCTION__);
- if (!isValid(descriptor)) {
- ALOGE("registerCallback: Unkown function descriptor: %d",
- static_cast<int32_t>(descriptor));
- return Error::BadParameter;
- }
- ALOGV("registerCallback(%s, %p, %p)", to_string(descriptor).c_str(),
- callbackData, pointer);
-
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (pointer != nullptr) {
- mCallbacks[descriptor] = {callbackData, pointer};
- }
- else {
- ALOGV("unregisterCallback(%s)", to_string(descriptor).c_str());
- mCallbacks.erase(descriptor);
- return Error::None;
- }
-
- // Callback without the state lock held
- if (descriptor == Callback::Hotplug) {
- lock.unlock();
- auto hotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(pointer);
- for (const auto& iter : mDisplays) {
- hotplug(callbackData, iter.first, static_cast<int32_t>(Connection::Connected));
- }
- }
-
- return Error::None;
-}
-
-const native_handle_t* EmuHWC2::allocateDisplayColorBuffer(int width, int height) {
- const uint32_t layerCount = 1;
- const uint64_t graphicBufferId = 0; // not used
-
- buffer_handle_t h;
- uint32_t stride;
-
- if (GraphicBufferAllocator::get().allocate(
- width, height,
- PIXEL_FORMAT_RGBA_8888,
- layerCount,
- (GraphicBuffer::USAGE_HW_COMPOSER | GraphicBuffer::USAGE_HW_RENDER),
- &h, &stride,
- graphicBufferId, "EmuHWC2") == OK) {
- return static_cast<const native_handle_t*>(h);
- } else {
- return nullptr;
- }
-}
-
-void EmuHWC2::freeDisplayColorBuffer(const native_handle_t* h) {
- GraphicBufferAllocator::get().free(h);
-}
-
-// Display functions
-
-#define VSYNC_PERIOD_PROP "ro.kernel.qemu.vsync"
-#define GRALLOC_PROP "ro.hardware.gralloc"
-
-static int getVsyncHzFromProperty() {
- char displaysValue[PROPERTY_VALUE_MAX] = "";
- property_get(VSYNC_PERIOD_PROP, displaysValue, "");
- bool isValid = displaysValue[0] != '\0';
-
- if (!isValid) return 60;
-
- long vsyncPeriodParsed = strtol(displaysValue, 0, 10);
-
- // On failure, strtol returns 0. Also, there's no reason to have 0
- // as the vsync period.
- if (!vsyncPeriodParsed) return 60;
-
- return static_cast<int>(vsyncPeriodParsed);
-}
-
-static bool getIsMinigbmFromProperty() {
- char grallocValue[PROPERTY_VALUE_MAX] = "";
- property_get(GRALLOC_PROP, grallocValue, "");
- bool isValid = grallocValue[0] != '\0';
-
- if (!isValid) return false;
-
- bool res = 0 == strcmp("minigbm", grallocValue);
-
- if (res) {
- ALOGD("%s: Is using minigbm, in minigbm mode.\n", __func__);
- } else {
- ALOGD("%s: Is not using minigbm, in goldfish mode.\n", __func__);
- }
-
- return res;
-}
-
-std::atomic<hwc2_display_t> EmuHWC2::Display::sNextId(0);
-
-EmuHWC2::Display::Display(EmuHWC2& device, DisplayType type, int width, int height)
- : mDevice(device),
- mIsMinigbm(getIsMinigbmFromProperty()),
- mId(sNextId++),
- mHostDisplayId(0),
- mName(),
- mType(type),
- mPowerMode(PowerMode::Off),
- mVsyncEnabled(Vsync::Invalid),
- mVsyncPeriod(1000*1000*1000/getVsyncHzFromProperty()), // vsync is 60 hz
- mVsyncThread(*this),
- mClientTarget(),
- mChanges(),
- mLayers(),
- mReleaseLayerIds(),
- mReleaseFences(),
- mConfigs(),
- mActiveConfig(nullptr),
- mColorModes(),
- mSetColorTransform(false),
- mStateMutex() {
-
- mTargetCb = device.allocateDisplayColorBuffer(width, height);
-
- if (mIsMinigbm) {
-
- mTargetDrmBuffer.reset(new DrmBuffer(mTargetCb, mDevice.mVirtioGpu));
- mVsyncPeriod = 1000*1000*1000 / mDevice.mVirtioGpu.refreshRate();
- }
-
- mVsyncThread.run("", ANDROID_PRIORITY_URGENT_DISPLAY);
-}
-
-EmuHWC2::Display::~Display() {
- mDevice.freeDisplayColorBuffer(mTargetCb);
-}
-
-Error EmuHWC2::Display::acceptChanges() {
- ALOGVV("%s: displayId %u", __FUNCTION__, (uint32_t)mId);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!mChanges) {
- ALOGW("%s: displayId %u acceptChanges failed, not validated",
- __FUNCTION__, (uint32_t)mId);
- return Error::NotValidated;
- }
-
-
- for (auto& change : mChanges->getTypeChanges()) {
- auto layerId = change.first;
- auto type = change.second;
- if (mDevice.mLayers.count(layerId) == 0) {
- // This should never happen but somehow does.
- ALOGW("Cannot accept change for unknown layer %u",
- (uint32_t)layerId);
- continue;
- }
- auto layer = mDevice.mLayers[layerId];
- layer->setCompositionType((int32_t)type);
- }
-
- mChanges->clearTypeChanges();
- return Error::None;
-}
-
-Error EmuHWC2::Display::createLayer(hwc2_layer_t* outLayerId) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- auto layer = *mLayers.emplace(std::make_shared<Layer>(*this));
- mDevice.mLayers.emplace(std::make_pair(layer->getId(), layer));
- *outLayerId = layer->getId();
- ALOGV("%s: Display %u created layer %u", __FUNCTION__, (uint32_t)mId,
- (uint32_t)(*outLayerId));
- return Error::None;
-}
-
-Error EmuHWC2::Display::destroyLayer(hwc2_layer_t layerId) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- const auto mapLayer = mDevice.mLayers.find(layerId);
- if (mapLayer == mDevice.mLayers.end()) {
- ALOGW("%s failed: no such layer, displayId %u layerId %u",
- __FUNCTION__, (uint32_t)mId, (uint32_t)layerId);
- return Error::BadLayer;
- }
- const auto layer = mapLayer->second;
- mDevice.mLayers.erase(mapLayer);
- const auto zRange = mLayers.equal_range(layer);
- for (auto current = zRange.first; current != zRange.second; ++current) {
- if (**current == *layer) {
- current = mLayers.erase(current);
- break;
- }
- }
- ALOGV("%s: displayId %d layerId %d", __FUNCTION__, (uint32_t)mId,
- (uint32_t)layerId);
- return Error::None;
-}
-
-Error EmuHWC2::Display::getActiveConfig(hwc2_config_t* outConfig) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!mActiveConfig) {
- ALOGW("%s: displayId %d %s", __FUNCTION__, (uint32_t)mId,
- to_string(Error::BadConfig).c_str());
- return Error::BadConfig;
- }
- auto configId = mActiveConfig->getId();
- ALOGV("%s: displayId %d configId %d", __FUNCTION__,
- (uint32_t)mId, (uint32_t)configId);
- *outConfig = configId;
- return Error::None;
-}
-
-Error EmuHWC2::Display::getDisplayAttribute(hwc2_config_t configId,
- int32_t attribute, int32_t* outValue) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (configId > mConfigs.size() || !mConfigs[configId]->isOnDisplay(*this)) {
- ALOGW("%s: bad config (%u %u)", __FUNCTION__, (uint32_t)mId, configId);
- return Error::BadConfig;
- }
- *outValue = mConfigs[configId]->getAttribute((Attribute)attribute);
- ALOGV("%s: (%d %d) %s --> %d", __FUNCTION__,
- (uint32_t)mId, (uint32_t)configId,
- to_string((Attribute)attribute).c_str(), *outValue);
- return Error::None;
-}
-
-Error EmuHWC2::Display::getChangedCompositionTypes(
- uint32_t* outNumElements, hwc2_layer_t* outLayers, int32_t* outTypes) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!mChanges) {
- ALOGW("display %u getChangedCompositionTypes failed: not validated",
- (uint32_t)mId);
- return Error::NotValidated;
- }
-
- if ((outLayers == nullptr) || (outTypes == nullptr)) {
- *outNumElements = mChanges->getTypeChanges().size();
- return Error::None;
- }
-
- uint32_t numWritten = 0;
- for (const auto& element : mChanges->getTypeChanges()) {
- if (numWritten == *outNumElements) {
- break;
- }
- auto layerId = element.first;
- auto intType = static_cast<int32_t>(element.second);
- ALOGV("%s: Adding layer %u %s", __FUNCTION__, (uint32_t)layerId,
- to_string(element.second).c_str());
- outLayers[numWritten] = layerId;
- outTypes[numWritten] = intType;
- ++numWritten;
- }
- *outNumElements = numWritten;
- return Error::None;
-}
-
-Error EmuHWC2::Display::getColorModes(uint32_t* outNumModes,
- int32_t* outModes) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!outModes) {
- *outNumModes = mColorModes.size();
- return Error::None;
- }
-
- // we only support HAL_COLOR_MODE_NATIVE so far
- uint32_t numModes = std::min(*outNumModes,
- static_cast<uint32_t>(mColorModes.size()));
- std::copy_n(mColorModes.cbegin(), numModes, outModes);
- *outNumModes = numModes;
- return Error::None;
-}
-
-Error EmuHWC2::Display::getConfigs(uint32_t* outNumConfigs,
- hwc2_config_t* outConfigs) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!outConfigs) {
- *outNumConfigs = mConfigs.size();
- return Error::None;
- }
- uint32_t numWritten = 0;
- for (const auto config : mConfigs) {
- if (numWritten == *outNumConfigs) {
- break;
- }
- outConfigs[numWritten] = config->getId();
- ++numWritten;
- }
- *outNumConfigs = numWritten;
- return Error::None;
-}
-
-Error EmuHWC2::Display::getDozeSupport(int32_t* outSupport) {
- ALOGVV("%s", __FUNCTION__);
- // We don't support so far
- *outSupport = 0;
- return Error::None;
-}
-
-Error EmuHWC2::Display::getHdrCapabilities(uint32_t* outNumTypes,
- int32_t* /*outTypes*/, float* /*outMaxLuminance*/,
- float* /*outMaxAverageLuminance*/, float* /*outMinLuminance*/) {
- ALOGVV("%s", __FUNCTION__);
- // We don't support so far
- *outNumTypes = 0;
- return Error::None;
-}
-
-Error EmuHWC2::Display::getName(uint32_t* outSize, char* outName) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!outName) {
- *outSize = mName.size();
- return Error::None;
- }
- auto numCopied = mName.copy(outName, *outSize);
- *outSize = numCopied;
- return Error::None;
-}
-
-Error EmuHWC2::Display::getReleaseFences(uint32_t* outNumElements,
- hwc2_layer_t* outLayers, int32_t* outFences) {
- ALOGVV("%s", __FUNCTION__);
-
- *outNumElements = mReleaseLayerIds.size();
-
- ALOGVV("%s. Got %u elements", __FUNCTION__, *outNumElements);
-
- if (*outNumElements && outLayers) {
- ALOGVV("%s. export release layers", __FUNCTION__);
- memcpy(outLayers, mReleaseLayerIds.data(),
- sizeof(hwc2_layer_t) * (*outNumElements));
- }
-
- if (*outNumElements && outFences) {
- ALOGVV("%s. export release fences", __FUNCTION__);
- memcpy(outFences, mReleaseFences.data(),
- sizeof(int32_t) * (*outNumElements));
- }
-
- return Error::None;
-}
-
-Error EmuHWC2::Display::getRequests(int32_t* outDisplayRequests,
- uint32_t* outNumElements, hwc2_layer_t* outLayers,
- int32_t* outLayerRequests) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!mChanges) {
- return Error::NotValidated;
- }
-
- if (outLayers == nullptr || outLayerRequests == nullptr) {
- *outNumElements = mChanges->getNumLayerRequests();
- return Error::None;
- }
-
- //TODO
- // Display requests (HWC2::DisplayRequest) are not supported so far:
- *outDisplayRequests = 0;
-
- uint32_t numWritten = 0;
- for (const auto& request : mChanges->getLayerRequests()) {
- if (numWritten == *outNumElements) {
- break;
- }
- outLayers[numWritten] = request.first;
- outLayerRequests[numWritten] = static_cast<int32_t>(request.second);
- ++numWritten;
- }
-
- return Error::None;
-}
-
-Error EmuHWC2::Display::getType(int32_t* outType) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- *outType = (int32_t)mType;
- return Error::None;
-}
-
-Error EmuHWC2::Display::present(int32_t* outRetireFence) {
- ALOGVV("%s", __FUNCTION__);
-
- *outRetireFence = -1;
-
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!mChanges || (mChanges->getNumTypes() > 0)) {
- ALOGE("%s display(%u) set failed: not validated", __FUNCTION__,
- (uint32_t)mId);
- return Error::NotValidated;
- }
- mChanges.reset();
-
- DEFINE_AND_VALIDATE_HOST_CONNECTION
- hostCon->lock();
- bool hostCompositionV1 = rcEnc->hasHostCompositionV1();
- bool hostCompositionV2 = rcEnc->hasHostCompositionV2();
- hostCon->unlock();
-
- // if we supports v2, then discard v1
- if (hostCompositionV2) {
- hostCompositionV1 = false;
- }
-
- if (hostCompositionV2 || hostCompositionV1) {
- uint32_t numLayer = 0;
- for (auto layer: mLayers) {
- if (layer->getCompositionType() == Composition::Device ||
- layer->getCompositionType() == Composition::SolidColor) {
- numLayer++;
- }
- }
-
- ALOGVV("present %d layers total %u layers",
- numLayer, (uint32_t)mLayers.size());
-
- mReleaseLayerIds.clear();
- mReleaseFences.clear();
-
- if (numLayer == 0) {
- ALOGW("No layers, exit, buffer %p", mClientTarget.getBuffer());
- if (mClientTarget.getBuffer()) {
- if (mIsMinigbm) {
- int retireFence = mClientTargetDrmBuffer->flush();
- *outRetireFence = dup(retireFence);
- close(retireFence);
- } else {
- post(hostCon, rcEnc, mClientTarget.getBuffer());
- *outRetireFence = mClientTarget.getFence();
- }
- }
- return Error::None;
- }
-
- if (hostCompositionV1) {
- if (mComposeMsg == nullptr || mComposeMsg->getLayerCnt() < numLayer) {
- mComposeMsg.reset(new ComposeMsg(numLayer));
- }
- } else {
- if (mComposeMsg_v2 == nullptr || mComposeMsg_v2->getLayerCnt() < numLayer) {
- mComposeMsg_v2.reset(new ComposeMsg_v2(numLayer));
- }
- }
-
- // Handle the composition
- ComposeDevice* p;
- ComposeDevice_v2* p2;
- ComposeLayer* l;
-
- if (hostCompositionV1) {
- p = mComposeMsg->get();
- l = p->layer;
- } else {
- p2 = mComposeMsg_v2->get();
- l = p2->layer;
- }
-
- for (auto layer: mLayers) {
- if (layer->getCompositionType() != Composition::Device &&
- layer->getCompositionType() != Composition::SolidColor) {
- ALOGE("%s: Unsupported composition types %d layer %u",
- __FUNCTION__, layer->getCompositionType(),
- (uint32_t)layer->getId());
- continue;
- }
- // send layer composition command to host
- if (layer->getCompositionType() == Composition::Device) {
- int fence = layer->getLayerBuffer().getFence();
- mReleaseLayerIds.push_back(layer->getId());
- if (fence != -1) {
- int err = sync_wait(fence, 3000);
- if (err < 0 && errno == ETIME) {
- ALOGE("%s waited on fence %d for 3000 ms",
- __FUNCTION__, fence);
- }
- close(fence);
- }
- else {
- ALOGV("%s: acquire fence not set for layer %u",
- __FUNCTION__, (uint32_t)layer->getId());
- }
- const native_handle_t *cb =
- layer->getLayerBuffer().getBuffer();
- if (cb != nullptr) {
- l->cbHandle = hostCon->grallocHelper()->getHostHandle(cb);
- }
- else {
- ALOGE("%s null buffer for layer %d", __FUNCTION__,
- (uint32_t)layer->getId());
- }
- }
- else {
- // solidcolor has no buffer
- l->cbHandle = 0;
- }
- l->composeMode = (hwc2_composition_t)layer->getCompositionType();
- l->displayFrame = layer->getDisplayFrame();
- l->crop = layer->getSourceCrop();
- l->blendMode = layer->getBlendMode();
- l->alpha = layer->getPlaneAlpha();
- l->color = layer->getColor();
- l->transform = layer->getTransform();
- ALOGV(" cb %d blendmode %d alpha %f %d %d %d %d z %d"
- " composeMode %d, transform %d",
- l->cbHandle, l->blendMode, l->alpha,
- l->displayFrame.left, l->displayFrame.top,
- l->displayFrame.right, l->displayFrame.bottom,
- layer->getZ(), l->composeMode, l->transform);
- l++;
- }
- if (hostCompositionV1) {
- p->version = 1;
- p->targetHandle = hostCon->grallocHelper()->getHostHandle(mTargetCb);
- p->numLayers = numLayer;
- } else {
- p2->version = 2;
- p2->displayId = mHostDisplayId;
- p2->targetHandle = hostCon->grallocHelper()->getHostHandle(mTargetCb);
- p2->numLayers = numLayer;
- }
-
- hostCon->lock();
- if (rcEnc->hasAsyncFrameCommands()) {
- if (mIsMinigbm) {
- if (hostCompositionV1) {
- rcEnc->rcComposeAsyncWithoutPost(rcEnc,
- sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
- (void *)p);
- } else {
- rcEnc->rcComposeAsyncWithoutPost(rcEnc,
- sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer),
- (void *)p2);
- }
- } else {
- if (hostCompositionV1) {
- rcEnc->rcComposeAsync(rcEnc,
- sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
- (void *)p);
- } else {
- rcEnc->rcComposeAsync(rcEnc,
- sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer),
- (void *)p2);
- }
- }
- } else {
- if (mIsMinigbm) {
- if (hostCompositionV1) {
- rcEnc->rcComposeWithoutPost(rcEnc,
- sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
- (void *)p);
- } else {
- rcEnc->rcComposeWithoutPost(rcEnc,
- sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer),
- (void *)p2);
- }
- } else {
- if (hostCompositionV1) {
- rcEnc->rcCompose(rcEnc,
- sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
- (void *)p);
- } else {
- rcEnc->rcCompose(rcEnc,
- sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer),
- (void *)p2);
- }
- }
- }
-
- hostCon->unlock();
-
- // Send a retire fence and use it as the release fence for all layers,
- // since media expects it
- EGLint attribs[] = { EGL_SYNC_NATIVE_FENCE_ANDROID, EGL_NO_NATIVE_FENCE_FD_ANDROID };
-
- uint64_t sync_handle, thread_handle;
- int retire_fd;
-
- hostCon->lock();
- rcEnc->rcCreateSyncKHR(rcEnc, EGL_SYNC_NATIVE_FENCE_ANDROID,
- attribs, 2 * sizeof(EGLint), true /* destroy when signaled */,
- &sync_handle, &thread_handle);
- hostCon->unlock();
-
- if (mIsMinigbm) {
- retire_fd = -1;
- retire_fd = mTargetDrmBuffer->flush();
- } else {
- goldfish_sync_queue_work(mSyncDeviceFd, sync_handle, thread_handle, &retire_fd);
- }
-
- for (size_t i = 0; i < mReleaseLayerIds.size(); ++i) {
- mReleaseFences.push_back(dup(retire_fd));
- }
-
- *outRetireFence = dup(retire_fd);
- close(retire_fd);
- hostCon->lock();
- if (rcEnc->hasAsyncFrameCommands()) {
- rcEnc->rcDestroySyncKHRAsync(rcEnc, sync_handle);
- } else {
- rcEnc->rcDestroySyncKHR(rcEnc, sync_handle);
- }
- hostCon->unlock();
-
- } else {
- // we set all layers Composition::Client, so do nothing.
- if (mIsMinigbm) {
- int retireFence = mClientTargetDrmBuffer->flush();
- *outRetireFence = dup(retireFence);
- close(retireFence);
- } else {
- post(hostCon, rcEnc, mClientTarget.getBuffer());
- *outRetireFence = mClientTarget.getFence();
- }
- ALOGV("%s fallback to post, returns outRetireFence %d",
- __FUNCTION__, *outRetireFence);
- }
-
- return Error::None;
-}
-
-Error EmuHWC2::Display::setActiveConfig(hwc2_config_t configId) {
- ALOGVV("%s %u", __FUNCTION__, (uint32_t)configId);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (configId > mConfigs.size() || !mConfigs[configId]->isOnDisplay(*this)) {
- ALOGW("%s: bad config (%u %u)", __FUNCTION__, (uint32_t)mId,
- (uint32_t)configId);
- return Error::BadConfig;
- }
- auto config = mConfigs[configId];
- if (config == mActiveConfig) {
- return Error::None;
- }
-
- mActiveConfig = config;
- return Error::None;
-}
-
-Error EmuHWC2::Display::setClientTarget(buffer_handle_t target,
- int32_t acquireFence, int32_t /*dataspace*/, hwc_region_t /*damage*/) {
- ALOGVV("%s", __FUNCTION__);
-
- std::unique_lock<std::mutex> lock(mStateMutex);
- mClientTarget.setBuffer(target);
- mClientTarget.setFence(acquireFence);
-
- // drm buffer
- if (mIsMinigbm) {
- mClientTargetDrmBuffer.reset(
- new DrmBuffer(static_cast<const native_handle_t*>(target), mDevice.mVirtioGpu));
- }
- return Error::None;
-}
-
-Error EmuHWC2::Display::setColorMode(int32_t intMode) {
- ALOGVV("%s %d", __FUNCTION__, intMode);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- auto mode = static_cast<android_color_mode_t>(intMode);
- ALOGV("%s: (display %u mode %d)", __FUNCTION__, (uint32_t)mId, intMode);
- if (mode == mActiveColorMode) {
- return Error::None;
- }
- if (mColorModes.count(mode) == 0) {
- ALOGE("%s: display %d Mode %d not found in mColorModes",
- __FUNCTION__, (uint32_t)mId, intMode);
- return Error::Unsupported;
- }
- mActiveColorMode = mode;
- return Error::None;
-}
-
-Error EmuHWC2::Display::setColorTransform(const float* /*matrix*/,
- int32_t hint) {
- ALOGVV("%s hint %d", __FUNCTION__, hint);
- std::unique_lock<std::mutex> lock(mStateMutex);
- //we force client composition if this is set
- if (hint == 0 ) {
- mSetColorTransform = false;
- }
- else {
- mSetColorTransform = true;
- }
- return Error::None;
-}
-
-Error EmuHWC2::Display::setOutputBuffer(buffer_handle_t /*buffer*/,
- int32_t /*releaseFence*/) {
- ALOGVV("%s", __FUNCTION__);
- //TODO: for virtual display
- return Error::None;
-}
-
-static bool isValid(PowerMode mode) {
- switch (mode) {
- case PowerMode::Off: // Fall-through
- case PowerMode::DozeSuspend: // Fall-through
- case PowerMode::Doze: // Fall-through
- case PowerMode::On: return true;
- default: return false;
- }
-}
-
-Error EmuHWC2::Display::setPowerMode(int32_t intMode) {
- ALOGVV("%s", __FUNCTION__);
- // Emulator always set screen ON
- PowerMode mode = static_cast<PowerMode>(intMode);
- if (!isValid(mode)) {
- return Error::BadParameter;
- }
- if (mode == mPowerMode) {
- return Error::None;
- }
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- ALOGV("%s: (display %u mode %s)", __FUNCTION__,
- (uint32_t)mId, to_string(mode).c_str());
- mPowerMode = mode;
- return Error::None;
-}
-
-static bool isValid(Vsync enable) {
- switch (enable) {
- case Vsync::Enable: // Fall-through
- case Vsync::Disable: return true;
- case Vsync::Invalid: return false;
- }
-}
-
-Error EmuHWC2::Display::setVsyncEnabled(int32_t intEnable) {
- ALOGVV("%s %d", __FUNCTION__, intEnable);
- Vsync enable = static_cast<Vsync>(intEnable);
- if (!isValid(enable)) {
- return Error::BadParameter;
- }
- if (enable == mVsyncEnabled) {
- return Error::None;
- }
-
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- mVsyncEnabled = enable;
- return Error::None;
-}
-
-Error EmuHWC2::Display::validate(uint32_t* outNumTypes,
- uint32_t* outNumRequests) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (!mChanges) {
- mChanges.reset(new Changes);
- DEFINE_AND_VALIDATE_HOST_CONNECTION
- hostCon->lock();
- bool hostCompositionV1 = rcEnc->hasHostCompositionV1();
- bool hostCompositionV2 = rcEnc->hasHostCompositionV2();
- hostCon->unlock();
-
- if (hostCompositionV1 || hostCompositionV2) {
- // Support Device and SolidColor, otherwise, fallback all layers
- // to Client
- bool fallBack = false;
- for (auto& layer : mLayers) {
- if (layer->getCompositionType() == Composition::Invalid) {
- // Log error for unused layers, layer leak?
- ALOGE("%s layer %u CompositionType(%d) not set",
- __FUNCTION__, (uint32_t)layer->getId(),
- layer->getCompositionType());
- continue;
- }
- if (layer->getCompositionType() == Composition::Client ||
- layer->getCompositionType() == Composition::Cursor ||
- layer->getCompositionType() == Composition::Sideband) {
- ALOGW("%s: layer %u CompositionType %d, fallback", __FUNCTION__,
- (uint32_t)layer->getId(), layer->getCompositionType());
- fallBack = true;
- break;
- }
- }
- if (mSetColorTransform) {
- fallBack = true;
- }
- if (fallBack) {
- for (auto& layer : mLayers) {
- if (layer->getCompositionType() == Composition::Invalid) {
- continue;
- }
- if (layer->getCompositionType() != Composition::Client) {
- mChanges->addTypeChange(layer->getId(),
- Composition::Client);
- }
- }
- }
- }
- else {
- for (auto& layer : mLayers) {
- if (layer->getCompositionType() != Composition::Client) {
- mChanges->addTypeChange(layer->getId(),
- Composition::Client);
- }
- }
- }
- }
- else {
- ALOGE("Validate was called more than once!");
- }
-
- *outNumTypes = mChanges->getNumTypes();
- *outNumRequests = mChanges->getNumLayerRequests();
- ALOGV("%s: displayId %u types %u, requests %u", __FUNCTION__,
- (uint32_t)mId, *outNumTypes, *outNumRequests);
- return *outNumTypes > 0 ? Error::HasChanges : Error::None;
-}
-
-Error EmuHWC2::Display::updateLayerZ(hwc2_layer_t layerId, uint32_t z) {
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- const auto mapLayer = mDevice.mLayers.find(layerId);
- if (mapLayer == mDevice.mLayers.end()) {
- ALOGE("%s failed to find layer %u", __FUNCTION__, (uint32_t)mId);
- return Error::BadLayer;
- }
-
- const auto layer = mapLayer->second;
- const auto zRange = mLayers.equal_range(layer);
- bool layerOnDisplay = false;
- for (auto current = zRange.first; current != zRange.second; ++current) {
- if (**current == *layer) {
- if ((*current)->getZ() == z) {
- // Don't change anything if the Z hasn't changed
- return Error::None;
- }
- current = mLayers.erase(current);
- layerOnDisplay = true;
- break;
- }
- }
-
- if (!layerOnDisplay) {
- ALOGE("%s failed to find layer %u on display", __FUNCTION__,
- (uint32_t)mId);
- return Error::BadLayer;
- }
-
- layer->setZ(z);
- mLayers.emplace(std::move(layer));
- return Error::None;
-}
-
-Error EmuHWC2::Display::getClientTargetSupport(uint32_t width, uint32_t height,
- int32_t format, int32_t dataspace){
- ALOGVV("%s", __FUNCTION__);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- if (mActiveConfig == nullptr) {
- return Error::Unsupported;
- }
-
- if (width == (uint32_t)mActiveConfig->getAttribute(Attribute::Width) &&
- height == (uint32_t)mActiveConfig->getAttribute(Attribute::Height) &&
- format == HAL_PIXEL_FORMAT_RGBA_8888 &&
- dataspace == HAL_DATASPACE_UNKNOWN) {
- return Error::None;
- }
-
- return Error::None;
-}
-
-// thess EDIDs are carefully generated according to the EDID spec version 1.3, more info
-// can be found from the following file:
-// frameworks/native/services/surfaceflinger/DisplayHardware/DisplayIdentification.cpp
-// approved pnp ids can be found here: https://uefi.org/pnp_id_list
-// pnp id: GGL, name: EMU_display_0, last byte is checksum
-// display id is local:8141603649153536
-static const uint8_t sEDID0[] = {
- 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1c, 0xec, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
- 0x1b, 0x10, 0x01, 0x03, 0x80, 0x50, 0x2d, 0x78, 0x0a, 0x0d, 0xc9, 0xa0, 0x57, 0x47, 0x98, 0x27,
- 0x12, 0x48, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
- 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc,
- 0x00, 0x45, 0x4d, 0x55, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x5f, 0x30, 0x00, 0x4b
-};
-
-// pnp id: GGL, name: EMU_display_1
-// display id is local:8140900251843329
-static const uint8_t sEDID1[] = {
- 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1c, 0xec, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
- 0x1b, 0x10, 0x01, 0x03, 0x80, 0x50, 0x2d, 0x78, 0x0a, 0x0d, 0xc9, 0xa0, 0x57, 0x47, 0x98, 0x27,
- 0x12, 0x48, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
- 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc,
- 0x00, 0x45, 0x4d, 0x55, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x5f, 0x31, 0x00, 0x3b
-};
-
-// pnp id: GGL, name: EMU_display_2
-// display id is local:8140940453066754
-static const uint8_t sEDID2[] = {
- 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1c, 0xec, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
- 0x1b, 0x10, 0x01, 0x03, 0x80, 0x50, 0x2d, 0x78, 0x0a, 0x0d, 0xc9, 0xa0, 0x57, 0x47, 0x98, 0x27,
- 0x12, 0x48, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
- 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc,
- 0x00, 0x45, 0x4d, 0x55, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x5f, 0x32, 0x00, 0x49
-};
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
-
-Error EmuHWC2::Display::getDisplayIdentificationData(uint8_t* outPort,
- uint32_t* outDataSize, uint8_t* outData) {
- ALOGVV("%s DisplayId %u", __FUNCTION__, (uint32_t)mId);
- if (outPort == nullptr || outDataSize == nullptr)
- return Error::BadParameter;
-
- uint32_t len = std::min(*outDataSize, (uint32_t)ARRAY_SIZE(sEDID0));
- if (outData != nullptr && len < (uint32_t)ARRAY_SIZE(sEDID0)) {
- ALOGW("%s DisplayId %u, small buffer size: %u is specified",
- __FUNCTION__, (uint32_t)mId, len);
- }
- *outDataSize = ARRAY_SIZE(sEDID0);
- switch (mId) {
- case 0:
- *outPort = 0;
- if (outData)
- memcpy(outData, sEDID0, len);
- break;
-
- case 1:
- *outPort = 1;
- if (outData)
- memcpy(outData, sEDID1, len);
- break;
-
- case 2:
- *outPort = 2;
- if (outData)
- memcpy(outData, sEDID2, len);
- break;
-
- default:
- *outPort = (uint8_t)mId;
- if (outData) {
- memcpy(outData, sEDID2, len);
- uint32_t size = ARRAY_SIZE(sEDID0);
- // change the name to EMU_display_<mID>
- // note the 3rd char from back is the number, _0, _1, _2, etc.
- if (len >= size - 2)
- outData[size-3] = '0' + (uint8_t)mId;
- if (len >= size) {
- // update the last byte, which is checksum byte
- uint8_t checksum = -(uint8_t)std::accumulate(
- outData, outData + size - 1, static_cast<uint8_t>(0));
- outData[size - 1] = checksum;
- }
- }
- break;
- }
-
- return Error::None;
-}
-
-Error EmuHWC2::Display::getDisplayCapabilities(uint32_t* outNumCapabilities,
- uint32_t* outCapabilities) {
- if (outNumCapabilities == nullptr) {
- return Error::None;
- }
-
- bool brightness_support = true;
- bool doze_support = true;
-
- uint32_t count = 1 + static_cast<uint32_t>(doze_support) + (brightness_support ? 1 : 0);
- int index = 0;
- if (outCapabilities != nullptr && (*outNumCapabilities >= count)) {
- outCapabilities[index++] = HWC2_DISPLAY_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM;
- if (doze_support) {
- outCapabilities[index++] = HWC2_DISPLAY_CAPABILITY_DOZE;
- }
- if (brightness_support) {
- outCapabilities[index++] = HWC2_DISPLAY_CAPABILITY_BRIGHTNESS;
- }
- }
-
- *outNumCapabilities = count;
- return Error::None;
-}
-
-Error EmuHWC2::Display::getDisplayBrightnessSupport(bool *out_support) {
- *out_support = false;
- return Error::None;
-}
-
-Error EmuHWC2::Display::setDisplayBrightness(float brightness) {
- ALOGW("TODO: setDisplayBrightness() is not implemented yet: brightness=%f", brightness);
- return Error::None;
-}
-
-int EmuHWC2::Display::populatePrimaryConfigs(int width, int height, int dpiX, int dpiY) {
- ALOGVV("%s DisplayId %u", __FUNCTION__, (uint32_t)mId);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- auto newConfig = std::make_shared<Config>(*this);
- // vsync is 60 hz;
- newConfig->setAttribute(Attribute::VsyncPeriod, mVsyncPeriod);
- newConfig->setAttribute(Attribute::Width, width);
- newConfig->setAttribute(Attribute::Height, height);
- newConfig->setAttribute(Attribute::DpiX, dpiX * 1000);
- newConfig->setAttribute(Attribute::DpiY, dpiY * 1000);
-
- newConfig->setId(static_cast<hwc2_config_t>(mConfigs.size()));
- ALOGV("Found new config %d: %s", (uint32_t)newConfig->getId(),
- newConfig->toString().c_str());
- mConfigs.emplace_back(std::move(newConfig));
-
- // Only have single config so far, it is activeConfig
- mActiveConfig = mConfigs[0];
- mActiveColorMode = HAL_COLOR_MODE_NATIVE;
- mColorModes.emplace((android_color_mode_t)HAL_COLOR_MODE_NATIVE);
-
- if (!mIsMinigbm) {
- mSyncDeviceFd = goldfish_sync_open();
- }
-
- return 0;
-}
-
-void EmuHWC2::Display::post(HostConnection *hostCon,
- ExtendedRCEncoderContext *rcEnc,
- buffer_handle_t h) {
- return;
- assert(cb && "native_handle_t::from(h) failed");
-
- hostCon->lock();
- rcEnc->rcFBPost(rcEnc, hostCon->grallocHelper()->getHostHandle(h));
- hostCon->flush();
- hostCon->unlock();
-}
-
-HWC2::Error EmuHWC2::Display::populateSecondaryConfigs(uint32_t width, uint32_t height,
- uint32_t dpi, uint32_t idx) {
- ALOGVV("%s DisplayId %u, width %u, height %u, dpi %u",
- __FUNCTION__, (uint32_t)mId, width, height, dpi);
- std::unique_lock<std::mutex> lock(mStateMutex);
-
- auto newConfig = std::make_shared<Config>(*this);
- // vsync is 60 hz;
- newConfig->setAttribute(Attribute::VsyncPeriod, mVsyncPeriod);
- newConfig->setAttribute(Attribute::Width, width);
- newConfig->setAttribute(Attribute::Height, height);
- newConfig->setAttribute(Attribute::DpiX, dpi*1000);
- newConfig->setAttribute(Attribute::DpiY, dpi*1000);
-
- int configId = mConfigs.size();
- newConfig->setId(static_cast<hwc2_config_t>(configId));
- ALOGV("Found new secondary config %d: %s", (uint32_t)newConfig->getId(),
- newConfig->toString().c_str());
- mConfigs.emplace_back(std::move(newConfig));
-
- mActiveConfig = mConfigs[configId];
- mActiveColorMode = HAL_COLOR_MODE_NATIVE;
- mColorModes.emplace((android_color_mode_t)HAL_COLOR_MODE_NATIVE);
-
- uint32_t displayId = hostDisplayIdStart + idx;
- DEFINE_AND_VALIDATE_HOST_CONNECTION
-
- hostCon->lock();
- rcEnc->rcDestroyDisplay(rcEnc, displayId);
- rcEnc->rcCreateDisplay(rcEnc, &displayId);
- rcEnc->rcSetDisplayPose(rcEnc, displayId, -1, -1, width, height);
- hostCon->unlock();
-
- if (displayId != hostDisplayIdStart + idx) {
- ALOGE("Something wrong with host displayId allocation, want %d "
- "allocated %d", hostDisplayIdStart + idx, displayId);
- }
- mHostDisplayId = displayId;
- ALOGVV("%s: mHostDisplayId=%d", __FUNCTION__, mHostDisplayId);
-
- return HWC2::Error::None;
-}
-
-
-// Config functions
-
-void EmuHWC2::Display::Config::setAttribute(Attribute attribute,
- int32_t value) {
- mAttributes[attribute] = value;
-}
-
-int32_t EmuHWC2::Display::Config::getAttribute(Attribute attribute) const {
- if (mAttributes.count(attribute) == 0) {
- return -1;
- }
- return mAttributes.at(attribute);
-}
-
-std::string EmuHWC2::Display::Config::toString() const {
- std::string output;
-
- const size_t BUFFER_SIZE = 100;
- char buffer[BUFFER_SIZE] = {};
- auto writtenBytes = snprintf(buffer, BUFFER_SIZE,
- "%u x %u", mAttributes.at(HWC2::Attribute::Width),
- mAttributes.at(HWC2::Attribute::Height));
- output.append(buffer, writtenBytes);
-
- if (mAttributes.count(HWC2::Attribute::VsyncPeriod) != 0) {
- std::memset(buffer, 0, BUFFER_SIZE);
- writtenBytes = snprintf(buffer, BUFFER_SIZE, " @ %.1f Hz",
- 1e9 / mAttributes.at(HWC2::Attribute::VsyncPeriod));
- output.append(buffer, writtenBytes);
- }
-
- if (mAttributes.count(HWC2::Attribute::DpiX) != 0 &&
- mAttributes.at(HWC2::Attribute::DpiX) != -1) {
- std::memset(buffer, 0, BUFFER_SIZE);
- writtenBytes = snprintf(buffer, BUFFER_SIZE,
- ", DPI: %.1f x %.1f",
- mAttributes.at(HWC2::Attribute::DpiX) / 1000.0f,
- mAttributes.at(HWC2::Attribute::DpiY) / 1000.0f);
- output.append(buffer, writtenBytes);
- }
-
- return output;
-}
-
-// VsyncThread function
-bool EmuHWC2::Display::VsyncThread::threadLoop() {
- struct timespec rt;
- if (clock_gettime(CLOCK_MONOTONIC, &rt) == -1) {
- ALOGE("%s: error in vsync thread clock_gettime: %s",
- __FUNCTION__, strerror(errno));
- return true;
- }
- const int logInterval = 60;
- int64_t lastLogged = rt.tv_sec;
- int sent = 0;
- int lastSent = 0;
- bool vsyncEnabled = false;
-
- struct timespec wait_time;
- wait_time.tv_sec = 0;
- wait_time.tv_nsec = mDisplay.mVsyncPeriod;
- const int64_t kOneRefreshNs = mDisplay.mVsyncPeriod;
- const int64_t kOneSecondNs = 1000ULL * 1000ULL * 1000ULL;
- int64_t lastTimeNs = -1;
- int64_t phasedWaitNs = 0;
- int64_t currentNs = 0;
-
- while (true) {
- clock_gettime(CLOCK_MONOTONIC, &rt);
- currentNs = rt.tv_nsec + rt.tv_sec * kOneSecondNs;
-
- if (lastTimeNs < 0) {
- phasedWaitNs = currentNs + kOneRefreshNs;
- } else {
- phasedWaitNs = kOneRefreshNs *
- (( currentNs - lastTimeNs) / kOneRefreshNs + 1) +
- lastTimeNs;
- }
-
- wait_time.tv_sec = phasedWaitNs / kOneSecondNs;
- wait_time.tv_nsec = phasedWaitNs - wait_time.tv_sec * kOneSecondNs;
-
- int ret;
- do {
- ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &wait_time, NULL);
- } while (ret == -1 && errno == EINTR);
-
- lastTimeNs = phasedWaitNs;
-
- std::unique_lock<std::mutex> lock(mDisplay.mStateMutex);
- vsyncEnabled = (mDisplay.mVsyncEnabled == Vsync::Enable);
- lock.unlock();
-
- if (!vsyncEnabled) {
- continue;
- }
-
- lock.lock();
- const auto& callbackInfo = mDisplay.mDevice.mCallbacks[Callback::Vsync];
- auto vsync = reinterpret_cast<HWC2_PFN_VSYNC>(callbackInfo.pointer);
- lock.unlock();
-
- if (vsync) {
- vsync(callbackInfo.data, mDisplay.mId, lastTimeNs);
- }
-
- if (rt.tv_sec - lastLogged >= logInterval) {
- ALOGVV("sent %d syncs in %ds", sent - lastSent, rt.tv_sec - lastLogged);
- lastLogged = rt.tv_sec;
- lastSent = sent;
- }
- ++sent;
- }
- return false;
-}
-
-
-// Layer functions
-bool EmuHWC2::SortLayersByZ::operator()(const std::shared_ptr<Layer>& lhs,
- const std::shared_ptr<Layer>& rhs) const {
- return lhs->getZ() < rhs->getZ();
-}
-
-std::atomic<hwc2_layer_t> EmuHWC2::Layer::sNextId(1);
-
-EmuHWC2::Layer::Layer(Display& display)
- : mId(sNextId++),
- mDisplay(display),
- mBuffer(),
- mSurfaceDamage(),
- mBlendMode(BlendMode::None),
- mColor({0, 0, 0, 0}),
- mCompositionType(Composition::Invalid),
- mDisplayFrame({0, 0, -1, -1}),
- mPlaneAlpha(0.0f),
- mSidebandStream(nullptr),
- mSourceCrop({0.0f, 0.0f, -1.0f, -1.0f}),
- mTransform(Transform::None),
- mVisibleRegion(),
- mZ(0)
- {}
-
-Error EmuHWC2::Layer::setBuffer(buffer_handle_t buffer,
- int32_t acquireFence) {
- ALOGVV("%s: Setting acquireFence %d for layer %u", __FUNCTION__,
- acquireFence, (uint32_t)mId);
- mBuffer.setBuffer(buffer);
- mBuffer.setFence(acquireFence);
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setCursorPosition(int32_t /*x*/,
- int32_t /*y*/) {
- ALOGVV("%s layer %u", __FUNCTION__, (uint32_t)mId);
- if (mCompositionType != Composition::Cursor) {
- ALOGE("%s: CompositionType not Cursor type", __FUNCTION__);
- return Error::BadLayer;
- }
- //TODO
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setSurfaceDamage(hwc_region_t /*damage*/) {
- // Emulator redraw whole layer per frame, so ignore this.
- ALOGVV("%s", __FUNCTION__);
- return Error::None;
-}
-
-// Layer state functions
-
-Error EmuHWC2::Layer::setBlendMode(int32_t mode) {
- ALOGVV("%s %d for layer %u", __FUNCTION__, mode, (uint32_t)mId);
- mBlendMode = static_cast<BlendMode>(mode);
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setColor(hwc_color_t color) {
- ALOGVV("%s layer %u %d", __FUNCTION__, (uint32_t)mId, color);
- mColor = color;
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setCompositionType(int32_t type) {
- ALOGVV("%s layer %u %u", __FUNCTION__, (uint32_t)mId, type);
- mCompositionType = static_cast<Composition>(type);
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setDataspace(int32_t) {
- ALOGVV("%s", __FUNCTION__);
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setDisplayFrame(hwc_rect_t frame) {
- ALOGVV("%s layer %u", __FUNCTION__, (uint32_t)mId);
- mDisplayFrame = frame;
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setPlaneAlpha(float alpha) {
- ALOGVV("%s layer %u %f", __FUNCTION__, (uint32_t)mId, alpha);
- mPlaneAlpha = alpha;
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setSidebandStream(const native_handle_t* stream) {
- ALOGVV("%s layer %u", __FUNCTION__, (uint32_t)mId);
- mSidebandStream = stream;
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setSourceCrop(hwc_frect_t crop) {
- ALOGVV("%s layer %u", __FUNCTION__, (uint32_t)mId);
- mSourceCrop = crop;
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setTransform(int32_t transform) {
- ALOGVV("%s layer %u", __FUNCTION__, (uint32_t)mId);
- mTransform = static_cast<Transform>(transform);
- return Error::None;
-}
-
-static bool compareRects(const hwc_rect_t& rect1, const hwc_rect_t& rect2) {
- return rect1.left == rect2.left &&
- rect1.right == rect2.right &&
- rect1.top == rect2.top &&
- rect1.bottom == rect2.bottom;
-}
-
-Error EmuHWC2::Layer::setVisibleRegion(hwc_region_t visible) {
- ALOGVV("%s", __FUNCTION__);
- if ((getNumVisibleRegions() != visible.numRects) ||
- !std::equal(mVisibleRegion.begin(), mVisibleRegion.end(), visible.rects,
- compareRects)) {
- mVisibleRegion.resize(visible.numRects);
- std::copy_n(visible.rects, visible.numRects, mVisibleRegion.begin());
- }
- return Error::None;
-}
-
-Error EmuHWC2::Layer::setZ(uint32_t z) {
- ALOGVV("%s layer %u %d", __FUNCTION__, (uint32_t)mId, z);
- mZ = z;
- return Error::None;
-}
-
-// VirtioGPU
-EmuHWC2::VirtioGpu::VirtioGpu() {
- drmModeRes *res;
- drmModeConnector *conn;
-
- mFd = open("/dev/dri/card0", O_RDWR | O_CLOEXEC);
- if (mFd < 0) {
- ALOGE("%s Error opening virtioGPU device: %d", __func__, errno);
- return;
- }
-
- int univRet = drmSetClientCap(mFd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
- if (univRet) {
- ALOGE("%s: fail to set universal plane %d\n", __func__, univRet);
- }
-
- int atomicRet = drmSetClientCap(mFd, DRM_CLIENT_CAP_ATOMIC, 1);
-
- if (atomicRet) {
- ALOGE("%s: fail to set atomic operation %d, %d\n", __func__, atomicRet, errno);
- }
-
- ALOGD("%s: Did set universal planes and atomic cap\n", __func__);
-
- res = drmModeGetResources(mFd);
- if (res == nullptr) {
- ALOGE("%s Error reading drm resources: %d", __func__, errno);
- close(mFd);
- mFd = -1;
- return;
- }
-
- mCrtcId = res->crtcs[0];
- mConnectorId = res->connectors[0];
-
- drmModePlaneResPtr plane_res = drmModeGetPlaneResources(mFd);
- for (uint32_t i = 0; i < plane_res->count_planes; ++i) {
- drmModePlanePtr plane = drmModeGetPlane(mFd, plane_res->planes[i]);
- ALOGD("%s: plane id: %u crtcid %u fbid %u crtc xy %d %d xy %d %d\n", __func__,
- plane->plane_id,
- plane->crtc_id,
- plane->fb_id,
- plane->crtc_x,
- plane->crtc_y,
- plane->x,
- plane->y);
-
- drmModeObjectPropertiesPtr planeProps = drmModeObjectGetProperties(mFd, plane->plane_id, DRM_MODE_OBJECT_PLANE);
- bool found = false;
- bool isPrimaryOrOverlay = false;
- for (int i = 0; !found && (size_t)i < planeProps->count_props; ++i) {
- drmModePropertyPtr p = drmModeGetProperty(mFd, planeProps->props[i]);
- if (!strcmp(p->name, "CRTC_ID")) {
- mPlaneCrtcPropertyId = p->prop_id;
- ALOGD("%s: Found plane crtc property id. id: %u\n", __func__,
- mPlaneCrtcPropertyId);
- } else if (!strcmp(p->name, "FB_ID")) {
- mPlaneFbPropertyId = p->prop_id;
- ALOGD("%s: Found plane fb property id. id: %u\n", __func__,
- mPlaneFbPropertyId);
- } else if (!strcmp(p->name, "CRTC_X")) {
- mPlaneCrtcXPropertyId = p->prop_id;
- ALOGD("%s: Found plane crtc X property id. id: %u\n", __func__,
- mPlaneCrtcXPropertyId);
- } else if (!strcmp(p->name, "CRTC_Y")) {
- mPlaneCrtcYPropertyId = p->prop_id;
- ALOGD("%s: Found plane crtc Y property id. id: %u\n", __func__,
- mPlaneCrtcYPropertyId);
- } else if (!strcmp(p->name, "CRTC_W")) {
- mPlaneCrtcWPropertyId = p->prop_id;
- ALOGD("%s: Found plane crtc W property id. id: %u value: %u\n", __func__,
- mPlaneCrtcWPropertyId, (uint32_t)p->values[0]);
- } else if (!strcmp(p->name, "CRTC_H")) {
- mPlaneCrtcHPropertyId = p->prop_id;
- ALOGD("%s: Found plane crtc H property id. id: %u value: %u\n", __func__,
- mPlaneCrtcHPropertyId,
- (uint32_t)p->values[0]);
- } else if (!strcmp(p->name, "SRC_X")) {
- mPlaneSrcXPropertyId = p->prop_id;
- ALOGD("%s: Found plane src X property id. id: %u\n", __func__,
- mPlaneSrcXPropertyId);
- } else if (!strcmp(p->name, "SRC_Y")) {
- mPlaneSrcYPropertyId = p->prop_id;
- ALOGD("%s: Found plane src Y property id. id: %u\n", __func__,
- mPlaneSrcYPropertyId);
- } else if (!strcmp(p->name, "SRC_W")) {
- mPlaneSrcWPropertyId = p->prop_id;
- ALOGD("%s: Found plane src W property id. id: %u\n", __func__,
- mPlaneSrcWPropertyId);
- } else if (!strcmp(p->name, "SRC_H")) {
- mPlaneSrcHPropertyId = p->prop_id;
- ALOGD("%s: Found plane src H property id. id: %u\n", __func__,
- mPlaneSrcHPropertyId);
- } else if (!strcmp(p->name, "type")) {
- mPlaneTypePropertyId = p->prop_id;
- ALOGD("%s: Found plane type property id. id: %u\n", __func__,
- mPlaneTypePropertyId);
- ALOGD("%s: Plane property type value 0x%llx\n", __func__, (unsigned long long)p->values[0]);
- uint64_t type = p->values[0];
- switch (type) {
- case DRM_PLANE_TYPE_OVERLAY:
- case DRM_PLANE_TYPE_PRIMARY:
- isPrimaryOrOverlay = true;
- ALOGD("%s: Found a primary or overlay plane. plane id: %u type 0x%llx\n", __func__, plane->plane_id, (unsigned long long)type);
- break;
- default:
- break;
- }
- }
- drmModeFreeProperty(p);
- }
- drmModeFreeObjectProperties(planeProps);
-
- if (isPrimaryOrOverlay && ((1 << 0) & plane->possible_crtcs)) {
- mPlaneId = plane->plane_id;
- ALOGD("%s: found plane compatible with crtc id %d: %d\n", __func__, mCrtcId, mPlaneId);
- drmModeFreePlane(plane);
- break;
- }
-
- drmModeFreePlane(plane);
- }
- drmModeFreePlaneResources(plane_res);
-
- conn = drmModeGetConnector(mFd, mConnectorId);
- if (conn == nullptr) {
- ALOGE("%s Error reading drm connector %d: %d", __func__, mConnectorId, errno);
- drmModeFreeResources(res);
- close(mFd);
- mFd = -1;
- return;
- }
- memcpy(&mMode, &conn->modes[0], sizeof(drmModeModeInfo));
-
- drmModeCreatePropertyBlob(mFd, &mMode, sizeof(mMode), &mModeBlobId);
-
- mRefreshRateAsFloat = 1000.0f * mMode.clock / ((float)mMode.vtotal * (float)mMode.htotal);
- mRefreshRateAsInteger = (uint32_t)(mRefreshRateAsFloat + 0.5f);
-
- ALOGD("%s: using drm init. refresh rate of system is %f, rounding to %d. blob id %d\n", __func__,
- mRefreshRateAsFloat, mRefreshRateAsInteger, mModeBlobId);
-
- {
- drmModeObjectPropertiesPtr connectorProps = drmModeObjectGetProperties(mFd, mConnectorId, DRM_MODE_OBJECT_CONNECTOR);
- bool found = false;
- for (int i = 0; !found && (size_t)i < connectorProps->count_props; ++i) {
- drmModePropertyPtr p = drmModeGetProperty(mFd, connectorProps->props[i]);
- if (!strcmp(p->name, "CRTC_ID")) {
- mConnectorCrtcPropertyId = p->prop_id;
- ALOGD("%s: Found connector crtc id prop id: %u\n", __func__,
- mConnectorCrtcPropertyId);
- found = true;
- }
- drmModeFreeProperty(p);
- }
- drmModeFreeObjectProperties(connectorProps);
- }
-
- {
- drmModeObjectPropertiesPtr crtcProps = drmModeObjectGetProperties(mFd, mCrtcId, DRM_MODE_OBJECT_CRTC);
- bool found = false;
- for (int i = 0; !found && (size_t)i < crtcProps->count_props; ++i) {
- drmModePropertyPtr p = drmModeGetProperty(mFd, crtcProps->props[i]);
- if (!strcmp(p->name, "OUT_FENCE_PTR")) {
- mOutFencePtrId = p->prop_id;
- ALOGD("%s: Found out fence ptr id. id: %u\n", __func__,
- mOutFencePtrId);
- } else if (!strcmp(p->name, "ACTIVE")) {
- mCrtcActivePropretyId = p->prop_id;
- ALOGD("%s: Found out crtc active prop id %u\n", __func__,
- mCrtcActivePropretyId);
- } else if (!strcmp(p->name, "MODE_ID")) {
- mCrtcModeIdPropertyId = p->prop_id;
- ALOGD("%s: Found out crtc mode id prop id %u\n", __func__,
- mCrtcModeIdPropertyId);
- }
- drmModeFreeProperty(p);
- }
- drmModeFreeObjectProperties(crtcProps);
- }
-
- drmModeFreeConnector(conn);
- drmModeFreeResources(res);
- ALOGD("%s: Successfully initialized DRM backend", __func__);
-}
-
-EmuHWC2::VirtioGpu::~VirtioGpu() {
- close(mFd);
-}
-
-int EmuHWC2::VirtioGpu::setCrtc(hwc_drm_bo_t& bo) {
- int ret = drmModeSetCrtc(mFd, mCrtcId, bo.fb_id,
- 0, 0, &mConnectorId, 1, &mMode);
- ALOGV("%s: drm FB %d", __func__, bo.fb_id);
- if (ret) {
- ALOGE("%s: drmModeSetCrtc failed: %s (errno %d)",
- __func__, strerror(errno), errno);
- return -1;
- }
- return 0;
-}
-
-int EmuHWC2::VirtioGpu::getDrmFB(hwc_drm_bo_t& bo) {
- int ret = drmPrimeFDToHandle(mFd, bo.prime_fds[0], &bo.gem_handles[0]);
- if (ret) {
- ALOGE("%s: drmPrimeFDToHandle failed: %s (errno %d)",
- __func__, strerror(errno), errno);
- return -1;
- }
- ret = drmModeAddFB2(mFd, 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)",
- __func__, strerror(errno), errno);
- return -1;
- }
- ALOGV("%s: drm FB %d", __func__, bo.fb_id);
- return 0;
-}
-
-int EmuHWC2::VirtioGpu::clearDrmFB(hwc_drm_bo_t& bo) {
- int ret = 0;
- if (bo.fb_id) {
- if (drmModeRmFB(mFd, bo.fb_id)) {
- ALOGE("%s: drmModeRmFB failed: %s (errno %d)",
- __func__, strerror(errno), errno);
- }
- ret = -1;
- }
- if (bo.gem_handles[0]) {
- struct drm_gem_close gem_close = {};
- gem_close.handle = bo.gem_handles[0];
- if (drmIoctl(mFd, DRM_IOCTL_GEM_CLOSE, &gem_close)) {
- ALOGE("%s: DRM_IOCTL_GEM_CLOSE failed: %s (errno %d)",
- __func__, strerror(errno), errno);
- }
- ret = -1;
- }
- ALOGV("%s: drm FB %d", __func__, bo.fb_id);
- return ret;
-}
-
-bool EmuHWC2::VirtioGpu::supportComposeWithoutPost() {
- return true;
-}
-
-int EmuHWC2::VirtioGpu::exportSyncFdAndSetCrtc(hwc_drm_bo_t& bo) {
- mOutFence = -1;
-
- drmModeAtomicReqPtr pset = drmModeAtomicAlloc();
-
- int ret;
-
- if (!mDidSetCrtc) {
- ALOGVV("%s: Setting crtc.\n", __func__);
- ret = drmModeAtomicAddProperty(pset, mCrtcId, mCrtcActivePropretyId, 1);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mCrtcId, mCrtcModeIdPropertyId, mModeBlobId);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mConnectorId, mConnectorCrtcPropertyId, mCrtcId);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
-
- mDidSetCrtc = true;
- } else {
- ALOGVV("%s: Already set crtc\n", __func__);
- }
-
- ret = drmModeAtomicAddProperty(pset, mCrtcId, mOutFencePtrId, (uint64_t)(&mOutFence));
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
-
- ALOGVV("%s: set plane: plane id %d crtcid %d fbid %d bo w h %d %d\n", __func__,
- mPlaneId, mCrtcId, bo.fb_id, bo.width, bo.height);
-
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneCrtcPropertyId, mCrtcId);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneFbPropertyId, bo.fb_id);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneCrtcXPropertyId, 0);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneCrtcYPropertyId, 0);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneCrtcWPropertyId, bo.width);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneCrtcHPropertyId, bo.height);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneSrcXPropertyId, 0);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneSrcYPropertyId, 0);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneSrcWPropertyId, bo.width << 16);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
- ret = drmModeAtomicAddProperty(pset, mPlaneId, mPlaneSrcHPropertyId, bo.height << 16);
- if (ret < 0) { ALOGE("%s:%d: failed %d errno %d\n", __func__, __LINE__, ret, errno); }
-
- uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;
- ret = drmModeAtomicCommit(mFd, pset, flags, 0);
-
- if (ret) {
- ALOGE("%s: Atomic commit failed with %d %d\n", __func__,
- ret, errno);
- }
-
- if (pset)
- drmModeAtomicFree(pset);
-
- ALOGVV("%s: out fence: %d\n", __func__, mOutFence);
- return mOutFence;
-}
-
-EmuHWC2::DrmBuffer::DrmBuffer(const native_handle_t* handle,
- VirtioGpu& virtioGpu)
- : mVirtioGpu(virtioGpu), mBo({}) {
- if (!convertBoInfo(handle)) {
- mVirtioGpu.getDrmFB(mBo);
- }
-}
-
-EmuHWC2::DrmBuffer::~DrmBuffer() {
- mVirtioGpu.clearDrmFB(mBo);
-}
-
-int EmuHWC2::DrmBuffer::convertBoInfo(const native_handle_t* handle) {
- cros_gralloc_handle *gr_handle = (cros_gralloc_handle *)handle;
- if (!gr_handle) {
- ALOGE("%s: Null buffer handle", __func__);
- 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;
-}
-
-int EmuHWC2::DrmBuffer::flush() {
- return mVirtioGpu.exportSyncFdAndSetCrtc(mBo);
-}
-
-// Adaptor Helpers
-
-void EmuHWC2::populateCapabilities() {
- //TODO: add Capabilities
- // support virtualDisplay
- // support sideBandStream
- // support backGroundColor
- // we should not set this for HWC2, TODO: remove
- // mCapabilities.insert(Capability::PresentFenceIsNotReliable);
-}
-
-int EmuHWC2::populatePrimary() {
- int ret = 0;
- auto display = std::make_shared<Display>(*this, HWC2::DisplayType::Physical,
- mDisplayWidth, mDisplayHeight);
- ret = display->populatePrimaryConfigs(mDisplayWidth, mDisplayHeight,
- mDisplayDpiX, mDisplayDpiY);
- if (ret != 0) {
- return ret;
- }
- mDisplays.emplace(display->getId(), std::move(display));
- return ret;
-}
-
-// Note "hwservicemanager." is used to avoid selinux issue
-#define EXTERANL_DISPLAY_PROP "hwservicemanager.external.displays"
-
-// return 0 for successful, 1 if no external displays are specified
-// return < 0 if failed
-int EmuHWC2::populateSecondaryDisplays() {
- // this guest property, hwservicemanager.external.displays,
- // specifies multi-display info, with comma (,) as separator
- // each display has the following info:
- // physicalId,width,height,dpi,flags
- // serveral displays can be provided, e.g., following has 2 displays:
- // setprop hwservicemanager.external.displays 1,1200,800,120,0,2,1200,800,120,0
- std::vector<uint64_t> values;
- char displaysValue[PROPERTY_VALUE_MAX] = "";
- property_get(EXTERANL_DISPLAY_PROP, displaysValue, "");
- bool isValid = displaysValue[0] != '\0';
- if (isValid) {
- char *p = displaysValue;
- while (*p) {
- if (!isdigit(*p) && *p != ',' && *p != ' ') {
- isValid = false;
- break;
- }
- p ++;
- }
- if (!isValid) {
- ALOGE("Invalid syntax for the value of system prop: %s", EXTERANL_DISPLAY_PROP);
- }
- }
- if (!isValid) {
- // no external displays are specified
- return 1;
- }
- // parse all int values to a vector
- std::istringstream stream(displaysValue);
- for (uint64_t id; stream >> id;) {
- values.push_back(id);
- if (stream.peek() == ',')
- stream.ignore();
- }
- // each display has 5 values
- if ((values.size() % 5) != 0) {
- ALOGE("%s: invalid value for system property: %s", __FUNCTION__, EXTERANL_DISPLAY_PROP);
- return -1;
- }
- uint32_t idx = 0;
- while (!values.empty()) {
- // uint64_t physicalId = values[0];
- uint32_t width = values[1];
- uint32_t height = values[2];
- uint32_t dpi = values[3];
- // uint32_t flags = values[4];
- values.erase(values.begin(), values.begin() + 5);
-
- Error ret = Error::None;
- auto display = std::make_shared<Display>(*this, HWC2::DisplayType::Physical, width, height);
- ret = display->populateSecondaryConfigs(width, height, dpi, idx++);
- if (ret != Error::None) {
- return -2;
- }
- mDisplays.emplace(display->getId(), std::move(display));
- }
- return 0;
-}
-
-EmuHWC2::Display* EmuHWC2::getDisplay(hwc2_display_t id) {
- auto display = mDisplays.find(id);
- if (display == mDisplays.end()) {
- ALOGE("Failed to get display for id=%d", (uint32_t)id);
- return nullptr;
- }
- return display->second.get();
-}
-
-std::tuple<EmuHWC2::Layer*, Error> EmuHWC2::getLayer(
- hwc2_display_t displayId, hwc2_layer_t layerId) {
- auto display = getDisplay(displayId);
- if (!display) {
- ALOGE("%s: Fail to find display %d", __FUNCTION__, (uint32_t)displayId);
- return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadDisplay);
- }
-
- auto layerEntry = mLayers.find(layerId);
- if (layerEntry == mLayers.end()) {
- ALOGE("%s: Fail to find layer %d", __FUNCTION__, (uint32_t)layerId);
- return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadLayer);
- }
-
- auto layer = layerEntry->second;
- if (layer->getDisplay().getId() != displayId) {
- ALOGE("%s: layer %d not belongs to display %d", __FUNCTION__,
- (uint32_t)layerId, (uint32_t)displayId);
- return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadLayer);
- }
- return std::make_tuple(layer.get(), Error::None);
-}
-
-static int hwc2DevOpen(const struct hw_module_t *module, const char *name,
- struct hw_device_t **dev) {
- ALOGVV("%s ", __FUNCTION__);
- if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
- ALOGE("Invalid module name- %s", name);
- return -EINVAL;
- }
-
- EmuHWC2* ctx = new EmuHWC2();
- if (!ctx) {
- ALOGE("Failed to allocate EmuHWC2");
- return -ENOMEM;
- }
- int ret = ctx->populatePrimary();
- if (ret != 0) {
- ALOGE("Failed to populate primary display");
- return ret;
- }
-
- ret = ctx->populateSecondaryDisplays();
- if (ret < 0) {
- ALOGE("Failed to populate secondary displays");
- return ret;
- }
-
- ctx->common.module = const_cast<hw_module_t *>(module);
- *dev = &ctx->common;
- return 0;
-}
-}
-
-static struct hw_module_methods_t hwc2_module_methods = {
- .open = android::hwc2DevOpen
-};
-
-hw_module_t HAL_MODULE_INFO_SYM = {
- .tag = HARDWARE_MODULE_TAG,
- .version_major = 2,
- .version_minor = 0,
- .id = HWC_HARDWARE_MODULE_ID,
- .name = "goldfish HWC2 module",
- .author = "The Android Open Source Project",
- .methods = &hwc2_module_methods,
- .dso = NULL,
- .reserved = {0},
-};
diff --git a/system/hwc2/EmuHWC2.h b/system/hwc2/EmuHWC2.h
deleted file mode 100644
index d0fb01a..0000000
--- a/system/hwc2/EmuHWC2.h
+++ /dev/null
@@ -1,563 +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.
- */
-
-#ifndef ANDROID_HW_EMU_HWC2_H
-#define ANDROID_HW_EMU_HWC2_H
-
-#define HWC2_INCLUDE_STRINGIFICATION
-#define HWC2_USE_CPP11
-#include <hardware/hwcomposer2.h>
-#undef HWC2_INCLUDE_STRINGIFICATION
-#undef HWC2_USE_CPP11
-#include <utils/Thread.h>
-
-#include <android-base/unique_fd.h>
-#include <atomic>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <numeric>
-#include <sstream>
-#include <vector>
-#include <unordered_set>
-#include <unordered_map>
-#include <set>
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-
-#include <cutils/native_handle.h>
-
-#include "include/drmhwcgralloc.h"
-#include "HostConnection.h"
-
-namespace android {
-
-class EmuHWC2 : public hwc2_device_t {
-public:
- EmuHWC2();
- int populatePrimary();
- int populateSecondaryDisplays();
-
-private:
- static inline EmuHWC2* getHWC2(hwc2_device_t* device) {
- return static_cast<EmuHWC2*>(device);
- }
-
- static int closeHook(hw_device_t* device) {
- EmuHWC2 *ctx = reinterpret_cast<EmuHWC2*>(device);
- delete ctx;
- return 0;
- }
-
- // getCapabilities
- void doGetCapabilities(uint32_t* outCount, int32_t* outCapabilities);
- static void getCapabilitiesHook(hwc2_device_t* device, uint32_t* outCount,
- int32_t* outCapabilities) {
- getHWC2(device)->doGetCapabilities(outCount, outCapabilities);
- }
-
- // getFunction
- hwc2_function_pointer_t doGetFunction(HWC2::FunctionDescriptor descriptor);
- static hwc2_function_pointer_t getFunctionHook(hwc2_device_t* device,
- int32_t desc) {
- auto descriptor = static_cast<HWC2::FunctionDescriptor>(desc);
- return getHWC2(device)->doGetFunction(descriptor);
- }
-
- // Device functions
- HWC2::Error createVirtualDisplay(uint32_t width, uint32_t height,
- int32_t* format, hwc2_display_t* outDisplay);
- static int32_t createVirtualDisplayHook(hwc2_device_t* device,
- uint32_t width, uint32_t height, int32_t* format,
- hwc2_display_t* outDisplay) {
- auto error = getHWC2(device)->createVirtualDisplay(width, height,
- format, outDisplay);
- return static_cast<int32_t>(error);
- }
-
- HWC2::Error destroyVirtualDisplay(hwc2_display_t display);
- static int32_t destroyVirtualDisplayHook(hwc2_device_t* device,
- hwc2_display_t display) {
- auto error = getHWC2(device)->destroyVirtualDisplay(display);
- return static_cast<int32_t>(error);
- }
-
- std::string mDumpString;
- void dump(uint32_t* outSize, char* outBuffer);
- static void dumpHook(hwc2_device_t* device, uint32_t* outSize,
- char* outBuffer) {
- getHWC2(device)->dump(outSize, outBuffer);
- }
-
- uint32_t getMaxVirtualDisplayCount();
- static uint32_t getMaxVirtualDisplayCountHook(hwc2_device_t* device) {
- return getHWC2(device)->getMaxVirtualDisplayCount();
- }
-
- HWC2::Error registerCallback(HWC2::Callback descriptor,
- hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer);
- static int32_t registerCallbackHook(hwc2_device_t* device,
- int32_t intDesc, hwc2_callback_data_t callbackData,
- hwc2_function_pointer_t pointer) {
- auto descriptor = static_cast<HWC2::Callback>(intDesc);
- auto error = getHWC2(device)->registerCallback(descriptor,
- callbackData, pointer);
- return static_cast<int32_t>(error);
- }
-
- class Layer;
- class SortLayersByZ {
- public:
- bool operator()(const std::shared_ptr<Layer>& lhs,
- const std::shared_ptr<Layer>& rhs) const;
- };
-
- // SurfaceFlinger sets the ColorBuffer and its Fence handler for each
- // layer. This class is a container for these two.
- class FencedBuffer {
- public:
- FencedBuffer() : mBuffer(nullptr) {}
-
- void setBuffer(buffer_handle_t buffer) { mBuffer = buffer; }
- void setFence(int fenceFd) {
- mFence = std::make_shared<base::unique_fd>(fenceFd);
- }
-
- buffer_handle_t getBuffer() const { return mBuffer; }
- int getFence() const { return mFence ? dup(mFence->get()) : -1; }
-
- private:
- buffer_handle_t mBuffer;
- std::shared_ptr<base::unique_fd> mFence;
- };
-
- typedef struct compose_layer {
- uint32_t cbHandle;
- hwc2_composition_t composeMode;
- hwc_rect_t displayFrame;
- hwc_frect_t crop;
- int32_t blendMode;
- float alpha;
- hwc_color_t color;
- hwc_transform_t transform;
- } ComposeLayer;
- typedef struct compose_device {
- uint32_t version;
- uint32_t targetHandle;
- uint32_t numLayers;
- struct compose_layer layer[0];
- } ComposeDevice;
- typedef struct compose_device_v2 {
- uint32_t version;
- uint32_t displayId;
- uint32_t targetHandle;
- uint32_t numLayers;
- struct compose_layer layer[0];
- } ComposeDevice_v2;
-
- class ComposeMsg {
- public:
- ComposeMsg(uint32_t layerCnt = 0) :
- mData(sizeof(ComposeDevice) + layerCnt * sizeof(ComposeLayer))
- {
- mComposeDevice = reinterpret_cast<ComposeDevice*>(mData.data());
- mLayerCnt = layerCnt;
- }
-
- ComposeDevice* get() { return mComposeDevice; }
-
- uint32_t getLayerCnt() { return mLayerCnt; }
-
- private:
- std::vector<uint8_t> mData;
- uint32_t mLayerCnt;
- ComposeDevice* mComposeDevice;
- };
-
- class ComposeMsg_v2 {
- public:
- ComposeMsg_v2(uint32_t layerCnt = 0) :
- mData(sizeof(ComposeDevice_v2) + layerCnt * sizeof(ComposeLayer))
- {
- mComposeDevice = reinterpret_cast<ComposeDevice_v2*>(mData.data());
- mLayerCnt = layerCnt;
- }
-
- ComposeDevice_v2* get() { return mComposeDevice; }
-
- uint32_t getLayerCnt() { return mLayerCnt; }
-
- private:
- std::vector<uint8_t> mData;
- uint32_t mLayerCnt;
- ComposeDevice_v2* mComposeDevice;
- };
-
- class VirtioGpu {
- public:
- VirtioGpu();
- ~VirtioGpu();
- int setCrtc(hwc_drm_bo_t& fb);
- int getDrmFB(hwc_drm_bo_t& bo);
- int clearDrmFB(hwc_drm_bo_t& bo);
- bool supportComposeWithoutPost();
- uint32_t refreshRate() const {
- return mRefreshRateAsInteger;
- }
-
- int exportSyncFdAndSetCrtc(hwc_drm_bo_t& fb);
-
- private:
- drmModeModeInfo mMode;
- int32_t mFd = -1;
- uint32_t mConnectorId;
- uint32_t mCrtcId;
-
- uint32_t mConnectorCrtcPropertyId;
-
- uint32_t mOutFencePtrId;
- uint32_t mCrtcActivePropretyId;
- uint32_t mCrtcModeIdPropertyId;
- uint32_t mModeBlobId;
-
- uint32_t mPlaneId;
- uint32_t mPlaneCrtcPropertyId;
- uint32_t mPlaneFbPropertyId;
- uint32_t mPlaneCrtcXPropertyId;
- uint32_t mPlaneCrtcYPropertyId;
- uint32_t mPlaneCrtcWPropertyId;
- uint32_t mPlaneCrtcHPropertyId;
- uint32_t mPlaneSrcXPropertyId;
- uint32_t mPlaneSrcYPropertyId;
- uint32_t mPlaneSrcWPropertyId;
- uint32_t mPlaneSrcHPropertyId;
- uint32_t mPlaneTypePropertyId;
- float mRefreshRateAsFloat;
- uint32_t mRefreshRateAsInteger;
-
- int mOutFence;
-
- bool mDidSetCrtc = false;
- };
-
- class DrmBuffer {
- public:
- DrmBuffer(const native_handle_t* handle, VirtioGpu& virtioGpu);
- ~DrmBuffer();
- int flush();
- private:
- int convertBoInfo(const native_handle_t* handle);
- VirtioGpu& mVirtioGpu;
- hwc_drm_bo_t mBo;
- };
-
-
- class Display {
- public:
- Display(EmuHWC2& device, HWC2::DisplayType type, int width, int height);
- ~Display();
- hwc2_display_t getId() const {return mId;}
-
- // HWC2 Display functions
- HWC2::Error acceptChanges();
- HWC2::Error createLayer(hwc2_layer_t* outLayerId);
- HWC2::Error destroyLayer(hwc2_layer_t layerId);
- HWC2::Error getActiveConfig(hwc2_config_t* outConfigId);
- HWC2::Error getDisplayAttribute(hwc2_config_t configId,
- int32_t attribute, int32_t* outValue);
- HWC2::Error getChangedCompositionTypes(uint32_t* outNumElements,
- hwc2_layer_t* outLayers, int32_t* outTypes);
- HWC2::Error getColorModes(uint32_t* outNumModes, int32_t* outModes);
- HWC2::Error getConfigs(uint32_t* outNumConfigs,
- hwc2_config_t* outConfigIds);
- HWC2::Error getDozeSupport(int32_t* outSupport);
- HWC2::Error getHdrCapabilities(uint32_t* outNumTypes,
- int32_t* outTypes, float* outMaxLuminance,
- float* outMaxAverageLuminance, float* outMinLuminance);
- HWC2::Error getName(uint32_t* outSize, char* outName);
- HWC2::Error getReleaseFences(uint32_t* outNumElements,
- hwc2_layer_t* outLayers, int32_t* outFences);
- HWC2::Error getRequests(int32_t* outDisplayRequests,
- uint32_t* outNumElements, hwc2_layer_t* outLayers,
- int32_t* outLayerRequests);
- HWC2::Error getType(int32_t* outType);
- HWC2::Error present(int32_t* outRetireFence);
- HWC2::Error setActiveConfig(hwc2_config_t configId);
- HWC2::Error setClientTarget(buffer_handle_t target,
- int32_t acquireFence, int32_t dataspace,
- hwc_region_t damage);
- HWC2::Error setColorMode(int32_t mode);
- HWC2::Error setColorTransform(const float* matrix,
- int32_t hint);
- HWC2::Error setOutputBuffer(buffer_handle_t buffer,
- int32_t releaseFence);
- HWC2::Error setPowerMode(int32_t mode);
- HWC2::Error setVsyncEnabled(int32_t enabled);
- HWC2::Error validate(uint32_t* outNumTypes,
- uint32_t* outNumRequests);
- HWC2::Error updateLayerZ(hwc2_layer_t layerId, uint32_t z);
- HWC2::Error getClientTargetSupport(uint32_t width, uint32_t height,
- int32_t format, int32_t dataspace);
- // 2.3 required functions
- HWC2::Error getDisplayIdentificationData(uint8_t* outPort,
- uint32_t* outDataSize, uint8_t* outData);
- HWC2::Error getDisplayCapabilities(uint32_t* outNumCapabilities,
- uint32_t* outCapabilities);
- HWC2::Error getDisplayBrightnessSupport(bool *out_support);
- HWC2::Error setDisplayBrightness(float brightness);
-
- // Read configs from PRIMARY Display
- int populatePrimaryConfigs(int width, int height, int dpiX, int dpiY);
- HWC2::Error populateSecondaryConfigs(uint32_t width, uint32_t height,
- uint32_t dpi, uint32_t idx);
-
- private:
- void post(HostConnection *hostCon, ExtendedRCEncoderContext *rcEnc,
- buffer_handle_t h);
-
- class Config {
- public:
- Config(Display& display)
- : mDisplay(display),
- mId(0),
- mAttributes() {}
-
- bool isOnDisplay(const Display& display) const {
- return display.getId() == mDisplay.getId();
- }
- void setAttribute(HWC2::Attribute attribute, int32_t value);
- int32_t getAttribute(HWC2::Attribute attribute) const;
- void setId(hwc2_config_t id) {mId = id; }
- hwc2_config_t getId() const {return mId; }
- std::string toString() const;
-
- private:
- Display& mDisplay;
- hwc2_config_t mId;
- std::unordered_map<HWC2::Attribute, int32_t> mAttributes;
- };
-
- // Stores changes requested from the device upon calling prepare().
- // Handles change request to:
- // - Layer composition type.
- // - Layer hints.
- class Changes {
- public:
- uint32_t getNumTypes() const {
- return static_cast<uint32_t>(mTypeChanges.size());
- }
-
- uint32_t getNumLayerRequests() const {
- return static_cast<uint32_t>(mLayerRequests.size());
- }
-
- const std::unordered_map<hwc2_layer_t, HWC2::Composition>&
- getTypeChanges() const {
- return mTypeChanges;
- }
-
- const std::unordered_map<hwc2_layer_t, HWC2::LayerRequest>&
- getLayerRequests() const {
- return mLayerRequests;
- }
-
- void addTypeChange(hwc2_layer_t layerId,
- HWC2::Composition type) {
- mTypeChanges.insert({layerId, type});
- }
-
- void clearTypeChanges() { mTypeChanges.clear(); }
-
- void addLayerRequest(hwc2_layer_t layerId,
- HWC2::LayerRequest request) {
- mLayerRequests.insert({layerId, request});
- }
-
- private:
- std::unordered_map<hwc2_layer_t, HWC2::Composition>
- mTypeChanges;
- std::unordered_map<hwc2_layer_t, HWC2::LayerRequest>
- mLayerRequests;
- };
-
- // Generate sw vsync signal
- class VsyncThread : public Thread {
- public:
- VsyncThread(Display& display)
- : mDisplay(display) {}
- virtual ~VsyncThread() {}
- private:
- Display& mDisplay;
- bool threadLoop() final;
- };
-
- private:
- EmuHWC2& mDevice;
- // Display ID generator.
- static std::atomic<hwc2_display_t> sNextId;
- static const uint32_t hostDisplayIdStart = 6;
- bool mIsMinigbm;
- const hwc2_display_t mId;
- // emulator side displayId
- uint32_t mHostDisplayId;
- std::string mName;
- HWC2::DisplayType mType;
- HWC2::PowerMode mPowerMode;
- HWC2::Vsync mVsyncEnabled;
- uint32_t mVsyncPeriod;
- VsyncThread mVsyncThread;
- FencedBuffer mClientTarget;
- // Will only be non-null after the Display has been validated and
- // before it has been presented
- std::unique_ptr<Changes> mChanges;
- // All layers this Display is aware of.
- std::multiset<std::shared_ptr<Layer>, SortLayersByZ> mLayers;
- std::vector<hwc2_display_t> mReleaseLayerIds;
- std::vector<int32_t> mReleaseFences;
- std::vector<std::shared_ptr<Config>> mConfigs;
- std::shared_ptr<const Config> mActiveConfig;
- std::set<android_color_mode_t> mColorModes;
- android_color_mode_t mActiveColorMode;
- bool mSetColorTransform;
- // The state of this display should only be modified from
- // SurfaceFlinger's main loop, with the exception of when dump is
- // called. To prevent a bad state from crashing us during a dump
- // call, all public calls into Display must acquire this mutex.
- mutable std::mutex mStateMutex;
- std::unique_ptr<ComposeMsg> mComposeMsg;
- std::unique_ptr<ComposeMsg_v2> mComposeMsg_v2;
- int mSyncDeviceFd;
- const native_handle_t* mTargetCb;
- std::unique_ptr<DrmBuffer> mTargetDrmBuffer;
- std::unique_ptr<DrmBuffer> mClientTargetDrmBuffer;
- };
-
- template<typename MF, MF memFunc, typename ...Args>
- static int32_t displayHook(hwc2_device_t* device, hwc2_display_t displayId,
- Args... args) {
- auto display = getHWC2(device)->getDisplay(displayId);
- if (!display) {
- return static_cast<int32_t>(HWC2::Error::BadDisplay);
- }
- auto error = ((*display).*memFunc)(std::forward<Args>(args)...);
- return static_cast<int32_t>(error);
- }
-
- class Layer {
- public:
- explicit Layer(Display& display);
- Display& getDisplay() const {return mDisplay;}
- hwc2_layer_t getId() const {return mId;}
- bool operator==(const Layer& other) { return mId == other.mId; }
- bool operator!=(const Layer& other) { return !(*this == other); }
-
- // HWC2 Layer functions
- HWC2::Error setBuffer(buffer_handle_t buffer, int32_t acquireFence);
- HWC2::Error setCursorPosition(int32_t x, int32_t y);
- HWC2::Error setSurfaceDamage(hwc_region_t damage);
-
- // HWC2 Layer state functions
- HWC2::Error setBlendMode(int32_t mode);
- HWC2::Error setColor(hwc_color_t color);
- HWC2::Error setCompositionType(int32_t type);
- HWC2::Error setDataspace(int32_t dataspace);
- HWC2::Error setDisplayFrame(hwc_rect_t frame);
- HWC2::Error setPlaneAlpha(float alpha);
- HWC2::Error setSidebandStream(const native_handle_t* stream);
- HWC2::Error setSourceCrop(hwc_frect_t crop);
- HWC2::Error setTransform(int32_t transform);
- HWC2::Error setVisibleRegion(hwc_region_t visible);
- HWC2::Error setZ(uint32_t z);
-
- HWC2::Composition getCompositionType() const {
- return mCompositionType;
- }
- hwc_color_t getColor() {return mColor; }
- uint32_t getZ() {return mZ; }
- std::size_t getNumVisibleRegions() {return mVisibleRegion.size(); }
- FencedBuffer& getLayerBuffer() {return mBuffer; }
- int32_t getBlendMode() {return (int32_t)mBlendMode; }
- float getPlaneAlpha() {return mPlaneAlpha; }
- hwc_frect_t getSourceCrop() {return mSourceCrop; }
- hwc_rect_t getDisplayFrame() {return mDisplayFrame; }
- hwc_transform_t getTransform() {return (hwc_transform_t)mTransform; }
- private:
- static std::atomic<hwc2_layer_t> sNextId;
- const hwc2_layer_t mId;
- Display& mDisplay;
- FencedBuffer mBuffer;
- std::vector<hwc_rect_t> mSurfaceDamage;
-
- HWC2::BlendMode mBlendMode;
- hwc_color_t mColor;
- HWC2::Composition mCompositionType;
- hwc_rect_t mDisplayFrame;
- float mPlaneAlpha;
- const native_handle_t* mSidebandStream;
- hwc_frect_t mSourceCrop;
- HWC2::Transform mTransform;
- std::vector<hwc_rect_t> mVisibleRegion;
- uint32_t mZ;
- };
-
- template <typename MF, MF memFunc, typename ...Args>
- static int32_t layerHook(hwc2_device_t* device, hwc2_display_t displayId,
- hwc2_layer_t layerId, Args... args) {
- auto result = getHWC2(device)->getLayer(displayId, layerId);
- auto error = std::get<HWC2::Error>(result);
- if (error == HWC2::Error::None) {
- auto layer = std::get<Layer*>(result);
- error = ((*layer).*memFunc)(std::forward<Args>(args)...);
- }
- return static_cast<int32_t>(error);
- }
-
- // helpers
- void populateCapabilities();
- Display* getDisplay(hwc2_display_t id);
- std::tuple<Layer*, HWC2::Error> getLayer(hwc2_display_t displayId,
- hwc2_layer_t layerId);
-
- HWC2::Error initDisplayParameters();
- const native_handle_t* allocateDisplayColorBuffer(int width, int height);
- void freeDisplayColorBuffer(const native_handle_t* h);
-
- std::unordered_set<HWC2::Capability> mCapabilities;
-
- // These are potentially accessed from multiple threads, and are protected
- // by this mutex.
- std::mutex mStateMutex;
-
- struct CallbackInfo {
- hwc2_callback_data_t data;
- hwc2_function_pointer_t pointer;
- };
- std::unordered_map<HWC2::Callback, CallbackInfo> mCallbacks;
-
- // use map so displays can be pluged in by order of ID, 0, 1, 2, 3, etc.
- std::map<hwc2_display_t, std::shared_ptr<Display>> mDisplays;
- std::unordered_map<hwc2_layer_t, std::shared_ptr<Layer>> mLayers;
-
- int mDisplayWidth;
- int mDisplayHeight;
- int mDisplayDpiX;
- int mDisplayDpiY;
-
- VirtioGpu mVirtioGpu;
-};
-
-}
-#endif
diff --git a/system/hwc2/FencedBuffer.h b/system/hwc2/FencedBuffer.h
new file mode 100644
index 0000000..dcbd094
--- /dev/null
+++ b/system/hwc2/FencedBuffer.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2021 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_FENCEDBUFFER_H
+#define ANDROID_HWC_FENCEDBUFFER_H
+
+#include <android-base/unique_fd.h>
+#include <cutils/native_handle.h>
+
+namespace android {
+
+class FencedBuffer {
+ public:
+ FencedBuffer() : mBuffer(nullptr) {}
+
+ void setBuffer(buffer_handle_t buffer) { mBuffer = buffer; }
+ void setFence(int fenceFd) {
+ mFence = std::make_shared<base::unique_fd>(fenceFd);
+ }
+
+ buffer_handle_t getBuffer() const { return mBuffer; }
+ int getFence() const { return mFence ? dup(mFence->get()) : -1; }
+
+ private:
+ buffer_handle_t mBuffer;
+ std::shared_ptr<android::base::unique_fd> mFence;
+};
+
+} // namespace android
+
+#endif
\ No newline at end of file
diff --git a/system/hwc2/Gralloc.cpp b/system/hwc2/Gralloc.cpp
new file mode 100644
index 0000000..ec33240
--- /dev/null
+++ b/system/hwc2/Gralloc.cpp
@@ -0,0 +1,493 @@
+/*
+ * Copyright (C) 2020 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 "Gralloc.h"
+
+#include <aidl/android/hardware/graphics/common/PlaneLayoutComponent.h>
+#include <aidl/android/hardware/graphics/common/PlaneLayoutComponentType.h>
+#include <drm_fourcc.h>
+#include <gralloctypes/Gralloc4.h>
+#include <hidl/ServiceManagement.h>
+#include <log/log.h>
+
+#include <algorithm>
+
+#include "Drm.h"
+
+using aidl::android::hardware::graphics::common::PlaneLayout;
+using aidl::android::hardware::graphics::common::PlaneLayoutComponent;
+using aidl::android::hardware::graphics::common::PlaneLayoutComponentType;
+using android::hardware::hidl_handle;
+using android::hardware::hidl_vec;
+using android::hardware::graphics::common::V1_2::BufferUsage;
+using android::hardware::graphics::mapper::V4_0::Error;
+using android::hardware::graphics::mapper::V4_0::IMapper;
+using MetadataType =
+ android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;
+
+namespace android {
+
+Gralloc::Gralloc() {
+ android::hardware::preloadPassthroughService<IMapper>();
+
+ gralloc4_ = IMapper::getService();
+ if (gralloc4_ != nullptr) {
+ ALOGE("%s using Gralloc4.", __FUNCTION__);
+ return;
+ }
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+
+ ALOGE("%s No Grallocs available!", __FUNCTION__);
+}
+
+Error Gralloc::GetMetadata(buffer_handle_t buffer, MetadataType type,
+ hidl_vec<uint8_t>* metadata) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return Error::NO_RESOURCES;
+ }
+
+ if (metadata == nullptr) {
+ return Error::BAD_VALUE;
+ }
+
+ Error error = Error::NONE;
+
+ auto native_handle = const_cast<native_handle_t*>(buffer);
+
+ auto ret =
+ gralloc4_->get(native_handle, type,
+ [&](const auto& get_error, const auto& get_metadata) {
+ error = get_error;
+ *metadata = get_metadata;
+ });
+
+ if (!ret.isOk()) {
+ error = Error::NO_RESOURCES;
+ }
+
+ if (error != Error::NONE) {
+ ALOGE("%s failed to get metadata %s", __FUNCTION__, type.name.c_str());
+ }
+ return error;
+}
+
+std::optional<uint32_t> Gralloc::GetWidth(buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ hidl_vec<uint8_t> encoded_width;
+
+ Error error = GetMetadata(buffer, android::gralloc4::MetadataType_Width,
+ &encoded_width);
+ if (error != Error::NONE) {
+ return std::nullopt;
+ }
+
+ uint64_t width = 0;
+ android::gralloc4::decodeWidth(encoded_width, &width);
+ return static_cast<uint32_t>(width);
+}
+
+std::optional<uint32_t> Gralloc::GetHeight(buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ hidl_vec<uint8_t> encoded_height;
+
+ Error error = GetMetadata(buffer, android::gralloc4::MetadataType_Height,
+ &encoded_height);
+ if (error != Error::NONE) {
+ return std::nullopt;
+ }
+
+ uint64_t height = 0;
+ android::gralloc4::decodeHeight(encoded_height, &height);
+ return static_cast<uint32_t>(height);
+}
+
+std::optional<uint32_t> Gralloc::GetDrmFormat(buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ hidl_vec<uint8_t> encoded_format;
+
+ Error error =
+ GetMetadata(buffer, android::gralloc4::MetadataType_PixelFormatFourCC,
+ &encoded_format);
+ if (error != Error::NONE) {
+ return std::nullopt;
+ }
+
+ uint32_t format = 0;
+ android::gralloc4::decodePixelFormatFourCC(encoded_format, &format);
+ return static_cast<uint32_t>(format);
+}
+
+std::optional<std::vector<PlaneLayout>> Gralloc::GetPlaneLayouts(
+ buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ hidl_vec<uint8_t> encoded_layouts;
+
+ Error error = GetMetadata(
+ buffer, android::gralloc4::MetadataType_PlaneLayouts, &encoded_layouts);
+ if (error != Error::NONE) {
+ return std::nullopt;
+ }
+
+ std::vector<PlaneLayout> plane_layouts;
+ android::gralloc4::decodePlaneLayouts(encoded_layouts, &plane_layouts);
+ return plane_layouts;
+}
+
+std::optional<uint32_t> Gralloc::GetMonoPlanarStrideBytes(
+ buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ auto plane_layouts_opt = GetPlaneLayouts(buffer);
+ if (!plane_layouts_opt) {
+ return std::nullopt;
+ }
+
+ std::vector<PlaneLayout>& plane_layouts = *plane_layouts_opt;
+ if (plane_layouts.size() != 1) {
+ return std::nullopt;
+ }
+
+ return static_cast<uint32_t>(plane_layouts[0].strideInBytes);
+}
+
+std::optional<GrallocBuffer> Gralloc::Import(buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ buffer_handle_t imported_buffer;
+
+ Error error;
+ auto ret =
+ gralloc4_->importBuffer(buffer, [&](const auto& err, const auto& buf) {
+ error = err;
+ if (err == Error::NONE) {
+ imported_buffer = static_cast<buffer_handle_t>(buf);
+ }
+ });
+
+ if (!ret.isOk() || error != Error::NONE) {
+ ALOGE("%s failed to import buffer", __FUNCTION__);
+ return std::nullopt;
+ }
+ return GrallocBuffer(this, imported_buffer);
+}
+
+void Gralloc::Release(buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return;
+ }
+
+ auto native_buffer = const_cast<native_handle_t*>(buffer);
+ auto ret = gralloc4_->freeBuffer(native_buffer);
+
+ if (!ret.isOk()) {
+ ALOGE("%s failed to release buffer", __FUNCTION__);
+ }
+}
+
+std::optional<void*> Gralloc::Lock(buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ auto native_buffer = const_cast<native_handle_t*>(buffer);
+
+ const auto buffer_usage = static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN |
+ BufferUsage::CPU_WRITE_OFTEN);
+
+ auto width_opt = GetWidth(buffer);
+ if (!width_opt) {
+ return std::nullopt;
+ }
+
+ auto height_opt = GetHeight(buffer);
+ if (!height_opt) {
+ return std::nullopt;
+ }
+
+ IMapper::Rect buffer_region;
+ buffer_region.left = 0;
+ buffer_region.top = 0;
+ buffer_region.width = *width_opt;
+ buffer_region.height = *height_opt;
+
+ // Empty fence, lock immedietly.
+ hidl_handle fence;
+
+ Error error = Error::NONE;
+ void* data = nullptr;
+
+ auto ret =
+ gralloc4_->lock(native_buffer, buffer_usage, buffer_region, fence,
+ [&](const auto& lock_error, const auto& lock_data) {
+ error = lock_error;
+ if (lock_error == Error::NONE) {
+ data = lock_data;
+ }
+ });
+
+ if (!ret.isOk()) {
+ error = Error::NO_RESOURCES;
+ }
+
+ if (error != Error::NONE) {
+ ALOGE("%s failed to lock buffer", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ return data;
+}
+
+std::optional<android_ycbcr> Gralloc::LockYCbCr(buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ auto format_opt = GetDrmFormat(buffer);
+ if (!format_opt) {
+ ALOGE("%s failed to check format of buffer", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ if (*format_opt != DRM_FORMAT_NV12 && *format_opt != DRM_FORMAT_NV21 &&
+ *format_opt != DRM_FORMAT_YVU420) {
+ ALOGE("%s called on non-ycbcr buffer", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ auto lock_opt = Lock(buffer);
+ if (!lock_opt) {
+ ALOGE("%s failed to lock buffer", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ auto plane_layouts_opt = GetPlaneLayouts(buffer);
+ if (!plane_layouts_opt) {
+ ALOGE("%s failed to get plane layouts", __FUNCTION__);
+ return std::nullopt;
+ }
+
+ android_ycbcr buffer_ycbcr;
+ buffer_ycbcr.y = nullptr;
+ buffer_ycbcr.cb = nullptr;
+ buffer_ycbcr.cr = nullptr;
+ buffer_ycbcr.ystride = 0;
+ buffer_ycbcr.cstride = 0;
+ buffer_ycbcr.chroma_step = 0;
+
+ for (const auto& plane_layout : *plane_layouts_opt) {
+ for (const auto& plane_layout_component : plane_layout.components) {
+ const auto& type = plane_layout_component.type;
+
+ if (!android::gralloc4::isStandardPlaneLayoutComponentType(type)) {
+ continue;
+ }
+
+ auto* component_data = reinterpret_cast<uint8_t*>(*lock_opt) +
+ plane_layout.offsetInBytes +
+ plane_layout_component.offsetInBits / 8;
+
+ switch (static_cast<PlaneLayoutComponentType>(type.value)) {
+ case PlaneLayoutComponentType::Y:
+ buffer_ycbcr.y = component_data;
+ buffer_ycbcr.ystride = plane_layout.strideInBytes;
+ break;
+ case PlaneLayoutComponentType::CB:
+ buffer_ycbcr.cb = component_data;
+ buffer_ycbcr.cstride = plane_layout.strideInBytes;
+ buffer_ycbcr.chroma_step = plane_layout.sampleIncrementInBits / 8;
+ break;
+ case PlaneLayoutComponentType::CR:
+ buffer_ycbcr.cr = component_data;
+ buffer_ycbcr.cstride = plane_layout.strideInBytes;
+ buffer_ycbcr.chroma_step = plane_layout.sampleIncrementInBits / 8;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ return buffer_ycbcr;
+}
+
+void Gralloc::Unlock(buffer_handle_t buffer) {
+ if (gralloc4_ == nullptr) {
+ ALOGE("%s Gralloc4 not available.", __FUNCTION__);
+ return;
+ }
+
+ auto native_handle = const_cast<native_handle_t*>(buffer);
+
+ Error error = Error::NONE;
+ auto ret = gralloc4_->unlock(
+ native_handle,
+ [&](const auto& unlock_error, const auto&) { error = unlock_error; });
+
+ if (!ret.isOk()) {
+ error = Error::NO_RESOURCES;
+ }
+
+ if (error != Error::NONE) {
+ ALOGE("%s failed to unlock buffer", __FUNCTION__);
+ }
+}
+
+GrallocBuffer::GrallocBuffer(Gralloc* gralloc, buffer_handle_t buffer)
+ : gralloc_(gralloc), buffer_(buffer) {}
+
+GrallocBuffer::~GrallocBuffer() { Release(); }
+
+GrallocBuffer::GrallocBuffer(GrallocBuffer&& rhs) { *this = std::move(rhs); }
+
+GrallocBuffer& GrallocBuffer::operator=(GrallocBuffer&& rhs) {
+ gralloc_ = rhs.gralloc_;
+ buffer_ = rhs.buffer_;
+ rhs.gralloc_ = nullptr;
+ rhs.buffer_ = nullptr;
+ return *this;
+}
+
+void GrallocBuffer::Release() {
+ if (gralloc_ && buffer_) {
+ gralloc_->Release(buffer_);
+ gralloc_ = nullptr;
+ buffer_ = nullptr;
+ }
+}
+
+std::optional<GrallocBufferView> GrallocBuffer::Lock() {
+ if (gralloc_ && buffer_) {
+ auto format_opt = GetDrmFormat();
+ if (!format_opt) {
+ ALOGE("%s failed to check format of buffer", __FUNCTION__);
+ return std::nullopt;
+ }
+ if (*format_opt != DRM_FORMAT_NV12 && *format_opt != DRM_FORMAT_NV21 &&
+ *format_opt != DRM_FORMAT_YVU420) {
+ auto locked_opt = gralloc_->Lock(buffer_);
+ if (!locked_opt) {
+ return std::nullopt;
+ }
+ return GrallocBufferView(this, *locked_opt);
+ } else {
+ auto locked_ycbcr_opt = gralloc_->LockYCbCr(buffer_);
+ if (!locked_ycbcr_opt) {
+ ALOGE("%s failed to lock ycbcr buffer", __FUNCTION__);
+ return std::nullopt;
+ }
+ return GrallocBufferView(this, *locked_ycbcr_opt);
+ }
+ }
+ return std::nullopt;
+}
+
+void GrallocBuffer::Unlock() {
+ if (gralloc_ && buffer_) {
+ gralloc_->Unlock(buffer_);
+ }
+}
+
+std::optional<uint32_t> GrallocBuffer::GetWidth() {
+ if (gralloc_ && buffer_) {
+ return gralloc_->GetWidth(buffer_);
+ }
+ return std::nullopt;
+}
+
+std::optional<uint32_t> GrallocBuffer::GetHeight() {
+ if (gralloc_ && buffer_) {
+ return gralloc_->GetHeight(buffer_);
+ }
+ return std::nullopt;
+}
+
+std::optional<uint32_t> GrallocBuffer::GetDrmFormat() {
+ if (gralloc_ && buffer_) {
+ return gralloc_->GetDrmFormat(buffer_);
+ }
+ return std::nullopt;
+}
+
+std::optional<std::vector<PlaneLayout>> GrallocBuffer::GetPlaneLayouts() {
+ if (gralloc_ && buffer_) {
+ return gralloc_->GetPlaneLayouts(buffer_);
+ }
+ return std::nullopt;
+}
+
+std::optional<uint32_t> GrallocBuffer::GetMonoPlanarStrideBytes() {
+ if (gralloc_ && buffer_) {
+ return gralloc_->GetMonoPlanarStrideBytes(buffer_);
+ }
+ return std::nullopt;
+}
+
+GrallocBufferView::GrallocBufferView(GrallocBuffer* buffer, void* raw)
+ : gralloc_buffer_(buffer), locked_(raw) {}
+
+GrallocBufferView::GrallocBufferView(GrallocBuffer* buffer, android_ycbcr raw)
+ : gralloc_buffer_(buffer), locked_ycbcr_(raw) {}
+
+GrallocBufferView::~GrallocBufferView() {
+ if (gralloc_buffer_) {
+ gralloc_buffer_->Unlock();
+ }
+}
+
+GrallocBufferView::GrallocBufferView(GrallocBufferView&& rhs) {
+ *this = std::move(rhs);
+}
+
+GrallocBufferView& GrallocBufferView::operator=(GrallocBufferView&& rhs) {
+ std::swap(gralloc_buffer_, rhs.gralloc_buffer_);
+ std::swap(locked_, rhs.locked_);
+ std::swap(locked_ycbcr_, rhs.locked_ycbcr_);
+ return *this;
+}
+
+const std::optional<void*> GrallocBufferView::Get() const { return locked_; }
+
+const std::optional<android_ycbcr>& GrallocBufferView::GetYCbCr() const {
+ return locked_ycbcr_;
+}
+
+} // namespace android
\ No newline at end of file
diff --git a/system/hwc2/Gralloc.h b/system/hwc2/Gralloc.h
new file mode 100644
index 0000000..9cb5153
--- /dev/null
+++ b/system/hwc2/Gralloc.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2020 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_GRALLOC_H
+#define ANDROID_HWC_GRALLOC_H
+
+#include <aidl/android/hardware/graphics/common/PlaneLayout.h>
+#include <android/hardware/graphics/mapper/4.0/IMapper.h>
+#include <hardware/gralloc.h>
+#include <system/graphics.h>
+#include <utils/StrongPointer.h>
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace android {
+
+class Gralloc;
+class GrallocBuffer;
+
+// An RAII object that will Unlock() a GrallocBuffer upon destruction.
+class GrallocBufferView {
+ public:
+ virtual ~GrallocBufferView();
+
+ GrallocBufferView(const GrallocBufferView& rhs) = delete;
+ GrallocBufferView& operator=(const GrallocBufferView& rhs) = delete;
+
+ GrallocBufferView(GrallocBufferView&& rhs);
+ GrallocBufferView& operator=(GrallocBufferView&& rhs);
+
+ const std::optional<void*> Get() const;
+
+ const std::optional<android_ycbcr>& GetYCbCr() const;
+
+ private:
+ friend class GrallocBuffer;
+ GrallocBufferView(GrallocBuffer* buffer, void* raw);
+ GrallocBufferView(GrallocBuffer* buffer, android_ycbcr raw);
+
+ // The GrallocBuffer that should be unlocked upon destruction of this object.
+ GrallocBuffer* gralloc_buffer_ = nullptr;
+
+ std::optional<void*> locked_;
+ std::optional<android_ycbcr> locked_ycbcr_;
+};
+
+// A gralloc 4.0 buffer that has been imported in the current process and
+// that will be released upon destruction. Users must ensure that the Gralloc
+// instance that this buffer is created with out lives this buffer.
+class GrallocBuffer {
+ public:
+ GrallocBuffer(Gralloc* gralloc, buffer_handle_t buffer);
+ virtual ~GrallocBuffer();
+
+ GrallocBuffer(const GrallocBuffer& rhs) = delete;
+ GrallocBuffer& operator=(const GrallocBuffer& rhs) = delete;
+
+ GrallocBuffer(GrallocBuffer&& rhs);
+ GrallocBuffer& operator=(GrallocBuffer&& rhs);
+
+ // Locks the buffer for reading and returns a view if successful.
+ std::optional<GrallocBufferView> Lock();
+
+ std::optional<uint32_t> GetWidth();
+ std::optional<uint32_t> GetHeight();
+ std::optional<uint32_t> GetDrmFormat();
+
+ // Returns the stride of the buffer if it is a single plane buffer or fails
+ // and returns nullopt if the buffer is for a multi plane buffer.
+ std::optional<uint32_t> GetMonoPlanarStrideBytes();
+
+ std::optional<
+ std::vector<aidl::android::hardware::graphics::common::PlaneLayout>>
+ GetPlaneLayouts();
+
+ private:
+ // Internal visibility for Unlock().
+ friend class GrallocBufferView;
+
+ // Unlocks the buffer from reading.
+ void Unlock();
+
+ void Release();
+
+ Gralloc* gralloc_ = nullptr;
+ buffer_handle_t buffer_ = nullptr;
+};
+
+class Gralloc {
+ public:
+ Gralloc();
+ virtual ~Gralloc() = default;
+
+ // Imports the given buffer handle into the current process and returns an
+ // imported buffer which can be used for reading. Users must ensure that the
+ // Gralloc instance outlives any GrallocBuffers.
+ std::optional<GrallocBuffer> Import(buffer_handle_t buffer);
+
+ private:
+ // The below functions are made avaialble only to GrallocBuffer so that
+ // users only call gralloc functions on *imported* buffers.
+ friend class GrallocBuffer;
+
+ // See GrallocBuffer::Release.
+ void Release(buffer_handle_t buffer);
+
+ // See GrallocBuffer::Lock.
+ std::optional<void*> Lock(buffer_handle_t buffer);
+
+ // See GrallocBuffer::LockYCbCr.
+ std::optional<android_ycbcr> LockYCbCr(buffer_handle_t buffer);
+
+ // See GrallocBuffer::Unlock.
+ void Unlock(buffer_handle_t buffer);
+
+ // See GrallocBuffer::GetWidth.
+ std::optional<uint32_t> GetWidth(buffer_handle_t buffer);
+
+ // See GrallocBuffer::GetHeight.
+ std::optional<uint32_t> GetHeight(buffer_handle_t buffer);
+
+ // See GrallocBuffer::GetDrmFormat.
+ std::optional<uint32_t> GetDrmFormat(buffer_handle_t buffer);
+
+ // See GrallocBuffer::GetPlaneLayouts.
+ std::optional<
+ std::vector<aidl::android::hardware::graphics::common::PlaneLayout>>
+ GetPlaneLayouts(buffer_handle_t buffer);
+
+ // Returns the stride of the buffer if it is a single plane buffer or fails
+ // and returns nullopt if the buffer is for a multi plane buffer.
+ std::optional<uint32_t> GetMonoPlanarStrideBytes(buffer_handle_t);
+
+ // See GrallocBuffer::GetMetadata.
+ android::hardware::graphics::mapper::V4_0::Error GetMetadata(
+ buffer_handle_t buffer,
+ android::hardware::graphics::mapper::V4_0::IMapper::MetadataType type,
+ android::hardware::hidl_vec<uint8_t>* metadata);
+
+ android::sp<android::hardware::graphics::mapper::V4_0::IMapper> gralloc4_;
+};
+
+} // namespace android
+
+#endif
\ No newline at end of file
diff --git a/system/hwc2/GuestComposer.cpp b/system/hwc2/GuestComposer.cpp
new file mode 100644
index 0000000..b00d5be
--- /dev/null
+++ b/system/hwc2/GuestComposer.cpp
@@ -0,0 +1,1185 @@
+/*
+ * Copyright 2021 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 "GuestComposer.h"
+
+#include <android-base/parseint.h>
+#include <android-base/properties.h>
+#include <android-base/strings.h>
+#include <android/hardware/graphics/common/1.0/types.h>
+#include <device_config_shared.h>
+#include <drm_fourcc.h>
+#include <libyuv.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/GraphicBufferAllocator.h>
+#include <ui/GraphicBufferMapper.h>
+
+#include "Device.h"
+#include "Display.h"
+#include "Drm.h"
+#include "Layer.h"
+
+namespace android {
+namespace {
+
+using android::hardware::graphics::common::V1_0::ColorTransform;
+
+uint64_t AlignToPower2(uint64_t val, uint8_t align_log) {
+ uint64_t align = 1ULL << align_log;
+ return ((val + (align - 1)) / align) * align;
+}
+
+bool LayerNeedsScaling(const Layer& layer) {
+ hwc_rect_t crop = layer.getSourceCropInt();
+ hwc_rect_t frame = layer.getDisplayFrame();
+
+ int fromW = crop.right - crop.left;
+ int fromH = crop.bottom - crop.top;
+ int toW = frame.right - frame.left;
+ int toH = frame.bottom - frame.top;
+
+ bool not_rot_scale = fromW != toW || fromH != toH;
+ bool rot_scale = fromW != toH || fromH != toW;
+
+ bool needs_rot = layer.getTransform() & HAL_TRANSFORM_ROT_90;
+
+ return needs_rot ? rot_scale : not_rot_scale;
+}
+
+bool LayerNeedsBlending(const Layer& layer) {
+ return layer.getBlendMode() != HWC2::BlendMode::None;
+}
+
+bool LayerNeedsAttenuation(const Layer& layer) {
+ return layer.getBlendMode() == HWC2::BlendMode::Coverage;
+}
+
+struct BufferSpec;
+typedef int (*ConverterFunction)(const BufferSpec& src, const BufferSpec& dst,
+ bool v_flip);
+int DoCopy(const BufferSpec& src, const BufferSpec& dst, bool vFlip);
+int ConvertFromRGB565(const BufferSpec& src, const BufferSpec& dst, bool vFlip);
+int ConvertFromYV12(const BufferSpec& src, const BufferSpec& dst, bool vFlip);
+
+ConverterFunction GetConverterForDrmFormat(uint32_t drmFormat) {
+ switch (drmFormat) {
+ case DRM_FORMAT_ABGR8888:
+ case DRM_FORMAT_XBGR8888:
+ return &DoCopy;
+ case DRM_FORMAT_RGB565:
+ return &ConvertFromRGB565;
+ case DRM_FORMAT_YVU420:
+ return &ConvertFromYV12;
+ }
+ ALOGW("Unsupported drm format: %d(%s), returning null converter", drmFormat,
+ GetDrmFormatString(drmFormat));
+ return nullptr;
+}
+
+bool IsDrmFormatSupported(uint32_t drmFormat) {
+ return GetConverterForDrmFormat(drmFormat) != nullptr;
+}
+
+// Libyuv's convert functions only allow the combination of any rotation
+// (multiple of 90 degrees) and a vertical flip, but not horizontal flips.
+// Surfaceflinger's transformations are expressed in terms of a vertical flip,
+// a horizontal flip and/or a single 90 degrees clockwise rotation (see
+// NATIVE_WINDOW_TRANSFORM_HINT documentation on system/window.h for more
+// insight). The following code allows to turn a horizontal flip into a 180
+// degrees rotation and a vertical flip.
+libyuv::RotationMode GetRotationFromTransform(uint32_t transform) {
+ uint32_t rotation =
+ (transform & HAL_TRANSFORM_ROT_90) ? 1 : 0; // 1 * ROT90 bit
+ rotation += (transform & HAL_TRANSFORM_FLIP_H) ? 2 : 0; // 2 * VFLIP bit
+ return static_cast<libyuv::RotationMode>(90 * rotation);
+}
+
+bool GetVFlipFromTransform(uint32_t transform) {
+ // vertical flip xor horizontal flip
+ return ((transform & HAL_TRANSFORM_FLIP_V) >> 1) ^
+ (transform & HAL_TRANSFORM_FLIP_H);
+}
+
+struct BufferSpec {
+ uint8_t* buffer;
+ std::optional<android_ycbcr> buffer_ycbcr;
+ int width;
+ int height;
+ int cropX;
+ int cropY;
+ int cropWidth;
+ int cropHeight;
+ uint32_t drmFormat;
+ int strideBytes;
+ int sampleBytes;
+
+ BufferSpec(uint8_t* buffer, std::optional<android_ycbcr> buffer_ycbcr,
+ int width, int height, int cropX, int cropY, int cropWidth,
+ int cropHeight, uint32_t drmFormat, int strideBytes,
+ int sampleBytes)
+ : buffer(buffer),
+ buffer_ycbcr(buffer_ycbcr),
+ width(width),
+ height(height),
+ cropX(cropX),
+ cropY(cropY),
+ cropWidth(cropWidth),
+ cropHeight(cropHeight),
+ drmFormat(drmFormat),
+ strideBytes(strideBytes),
+ sampleBytes(sampleBytes) {}
+
+ BufferSpec(uint8_t* buffer, int width, int height, int strideBytes)
+ : BufferSpec(buffer,
+ /*buffer_ycbcr=*/std::nullopt, width, height,
+ /*cropX=*/0,
+ /*cropY=*/0,
+ /*cropWidth=*/width,
+ /*cropHeight=*/height,
+ /*drmFormat=*/DRM_FORMAT_ABGR8888, strideBytes,
+ /*sampleBytes=*/4) {}
+};
+
+int ConvertFromRGB565(const BufferSpec& src, const BufferSpec& dst,
+ bool vFlip) {
+ // Point to the upper left corner of the crop rectangle
+ uint8_t* srcBuffer =
+ src.buffer + src.cropY * src.strideBytes + src.cropX * src.sampleBytes;
+ uint8_t* dstBuffer =
+ dst.buffer + dst.cropY * dst.strideBytes + dst.cropX * dst.sampleBytes;
+
+ int width = src.cropWidth;
+ int height = src.cropHeight;
+ if (vFlip) {
+ height = -height;
+ }
+
+ return libyuv::RGB565ToARGB(srcBuffer, src.strideBytes, //
+ dstBuffer, dst.strideBytes, //
+ width, height);
+}
+
+int ConvertFromYV12(const BufferSpec& src, const BufferSpec& dst, bool vFlip) {
+ // The following calculation of plane offsets and alignments are based on
+ // swiftshader's Sampler::setTextureLevel() implementation
+ // (Renderer/Sampler.cpp:225)
+
+ auto& srcBufferYCbCrOpt = src.buffer_ycbcr;
+ if (!srcBufferYCbCrOpt) {
+ ALOGE("%s called on non ycbcr buffer", __FUNCTION__);
+ return -1;
+ }
+ auto& srcBufferYCbCr = *srcBufferYCbCrOpt;
+
+ // The libyuv::I420ToARGB() function is for tri-planar.
+ if (srcBufferYCbCr.chroma_step != 1) {
+ ALOGE("%s called with bad chroma step", __FUNCTION__);
+ return -1;
+ }
+
+ uint8_t* srcY = reinterpret_cast<uint8_t*>(srcBufferYCbCr.y);
+ int strideY = srcBufferYCbCr.ystride;
+ uint8_t* srcU = reinterpret_cast<uint8_t*>(srcBufferYCbCr.cb);
+ int strideU = srcBufferYCbCr.cstride;
+ uint8_t* srcV = reinterpret_cast<uint8_t*>(srcBufferYCbCr.cr);
+ int strideV = srcBufferYCbCr.cstride;
+
+ // Adjust for crop
+ srcY += src.cropY * strideY + src.cropX;
+ srcV += (src.cropY / 2) * strideV + (src.cropX / 2);
+ srcU += (src.cropY / 2) * strideU + (src.cropX / 2);
+ uint8_t* dstBuffer =
+ dst.buffer + dst.cropY * dst.strideBytes + dst.cropX * dst.sampleBytes;
+
+ int width = dst.cropWidth;
+ int height = dst.cropHeight;
+
+ if (vFlip) {
+ height = -height;
+ }
+
+ // YV12 is the same as I420, with the U and V planes swapped
+ return libyuv::I420ToARGB(srcY, strideY, srcV, strideV, srcU, strideU,
+ dstBuffer, dst.strideBytes, width, height);
+}
+
+int DoConversion(const BufferSpec& src, const BufferSpec& dst, bool v_flip) {
+ ConverterFunction func = GetConverterForDrmFormat(src.drmFormat);
+ if (!func) {
+ // GetConverterForDrmFormat should've logged the issue for us.
+ return -1;
+ }
+ return func(src, dst, v_flip);
+}
+
+int DoCopy(const BufferSpec& src, const BufferSpec& dst, bool v_flip) {
+ // Point to the upper left corner of the crop rectangle
+ uint8_t* srcBuffer =
+ src.buffer + src.cropY * src.strideBytes + src.cropX * src.sampleBytes;
+ uint8_t* dstBuffer =
+ dst.buffer + dst.cropY * dst.strideBytes + dst.cropX * dst.sampleBytes;
+ int width = src.cropWidth;
+ int height = src.cropHeight;
+
+ if (v_flip) {
+ height = -height;
+ }
+
+ // HAL formats are named based on the order of the pixel components on the
+ // byte stream, while libyuv formats are named based on the order of those
+ // pixel components in an integer written from left to right. So
+ // libyuv::FOURCC_ARGB is equivalent to HAL_PIXEL_FORMAT_BGRA_8888.
+ auto ret = libyuv::ARGBCopy(srcBuffer, src.strideBytes, dstBuffer,
+ dst.strideBytes, width, height);
+ return ret;
+}
+
+int DoRotation(const BufferSpec& src, const BufferSpec& dst,
+ libyuv::RotationMode rotation, bool v_flip) {
+ // Point to the upper left corner of the crop rectangles
+ uint8_t* srcBuffer =
+ src.buffer + src.cropY * src.strideBytes + src.cropX * src.sampleBytes;
+ uint8_t* dstBuffer =
+ dst.buffer + dst.cropY * dst.strideBytes + dst.cropX * dst.sampleBytes;
+ int width = src.cropWidth;
+ int height = src.cropHeight;
+
+ if (v_flip) {
+ height = -height;
+ }
+
+ return libyuv::ARGBRotate(srcBuffer, src.strideBytes, dstBuffer,
+ dst.strideBytes, width, height, rotation);
+}
+
+int DoScaling(const BufferSpec& src, const BufferSpec& dst, bool v_flip) {
+ // Point to the upper left corner of the crop rectangles
+ uint8_t* srcBuffer =
+ src.buffer + src.cropY * src.strideBytes + src.cropX * src.sampleBytes;
+ uint8_t* dstBuffer =
+ dst.buffer + dst.cropY * dst.strideBytes + dst.cropX * dst.sampleBytes;
+ int srcWidth = src.cropWidth;
+ int srcHeight = src.cropHeight;
+ int dstWidth = dst.cropWidth;
+ int dstHeight = dst.cropHeight;
+
+ if (v_flip) {
+ srcHeight = -srcHeight;
+ }
+
+ return libyuv::ARGBScale(srcBuffer, src.strideBytes, srcWidth, srcHeight,
+ dstBuffer, dst.strideBytes, dstWidth, dstHeight,
+ libyuv::kFilterBilinear);
+}
+
+int DoAttenuation(const BufferSpec& src, const BufferSpec& dst, bool v_flip) {
+ // Point to the upper left corner of the crop rectangles
+ uint8_t* srcBuffer =
+ src.buffer + src.cropY * src.strideBytes + src.cropX * src.sampleBytes;
+ uint8_t* dstBuffer =
+ dst.buffer + dst.cropY * dst.strideBytes + dst.cropX * dst.sampleBytes;
+ int width = dst.cropWidth;
+ int height = dst.cropHeight;
+
+ if (v_flip) {
+ height = -height;
+ }
+
+ return libyuv::ARGBAttenuate(srcBuffer, src.strideBytes, dstBuffer,
+ dst.strideBytes, width, height);
+}
+
+int DoBlending(const BufferSpec& src, const BufferSpec& dst, bool v_flip) {
+ // Point to the upper left corner of the crop rectangles
+ uint8_t* srcBuffer =
+ src.buffer + src.cropY * src.strideBytes + src.cropX * src.sampleBytes;
+ uint8_t* dstBuffer =
+ dst.buffer + dst.cropY * dst.strideBytes + dst.cropX * dst.sampleBytes;
+ int width = dst.cropWidth;
+ int height = dst.cropHeight;
+
+ if (v_flip) {
+ height = -height;
+ }
+
+ // libyuv's ARGB format is hwcomposer's BGRA format, since blending only cares
+ // for the position of alpha in the pixel and not the position of the colors
+ // this function is perfectly usable.
+ return libyuv::ARGBBlend(srcBuffer, src.strideBytes, dstBuffer,
+ dst.strideBytes, dstBuffer, dst.strideBytes, width,
+ height);
+}
+
+std::optional<BufferSpec> GetBufferSpec(GrallocBuffer& buffer,
+ GrallocBufferView& bufferView,
+ const hwc_rect_t& bufferCrop) {
+ auto bufferFormatOpt = buffer.GetDrmFormat();
+ if (!bufferFormatOpt) {
+ ALOGE("Failed to get gralloc buffer format.");
+ return std::nullopt;
+ }
+ uint32_t bufferFormat = *bufferFormatOpt;
+
+ auto bufferWidthOpt = buffer.GetWidth();
+ if (!bufferWidthOpt) {
+ ALOGE("Failed to get gralloc buffer width.");
+ return std::nullopt;
+ }
+ uint32_t bufferWidth = *bufferWidthOpt;
+
+ auto bufferHeightOpt = buffer.GetHeight();
+ if (!bufferHeightOpt) {
+ ALOGE("Failed to get gralloc buffer height.");
+ return std::nullopt;
+ }
+ uint32_t bufferHeight = *bufferHeightOpt;
+
+ uint8_t* bufferData = nullptr;
+ uint32_t bufferStrideBytes = 0;
+ std::optional<android_ycbcr> bufferYCbCrData;
+
+ if (bufferFormat == DRM_FORMAT_NV12 || bufferFormat == DRM_FORMAT_NV21 ||
+ bufferFormat == DRM_FORMAT_YVU420) {
+ bufferYCbCrData = bufferView.GetYCbCr();
+ if (!bufferYCbCrData) {
+ ALOGE("%s failed to get raw ycbcr from view.", __FUNCTION__);
+ return std::nullopt;
+ }
+ } else {
+ auto bufferDataOpt = bufferView.Get();
+ if (!bufferDataOpt) {
+ ALOGE("%s failed to lock gralloc buffer.", __FUNCTION__);
+ return std::nullopt;
+ }
+ bufferData = reinterpret_cast<uint8_t*>(*bufferDataOpt);
+
+ auto bufferStrideBytesOpt = buffer.GetMonoPlanarStrideBytes();
+ if (!bufferStrideBytesOpt) {
+ ALOGE("%s failed to get plane stride.", __FUNCTION__);
+ return std::nullopt;
+ }
+ bufferStrideBytes = *bufferStrideBytesOpt;
+ }
+
+ return BufferSpec(bufferData, bufferYCbCrData, bufferWidth, bufferHeight,
+ bufferCrop.left, bufferCrop.top,
+ bufferCrop.right - bufferCrop.left,
+ bufferCrop.bottom - bufferCrop.top, bufferFormat,
+ bufferStrideBytes, GetDrmFormatBytesPerPixel(bufferFormat));
+}
+
+} // namespace
+
+HWC2::Error GuestComposer::init(const HotplugCallback& cb) {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ if (!mDrmPresenter.init(cb)) {
+ ALOGE("%s: failed to initialize DrmPresenter", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error GuestComposer::createDisplays(
+ Device* device, const AddDisplayToDeviceFunction& addDisplayToDeviceFn) {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ HWC2::Error error = HWC2::Error::None;
+
+ std::vector<DisplayConfig> displayConfigs;
+
+ error = getDisplayConfigsFromDeviceConfig(&displayConfigs);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to get display configs from device config", __FUNCTION__);
+ return error;
+ }
+
+ error = getDisplayConfigsFromSystemProp(&displayConfigs);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to get display configs from system prop", __FUNCTION__);
+ return error;
+ }
+ uint32_t id = 0;
+ for (const auto& displayConfig : displayConfigs) {
+ error = createDisplay(device, id, displayConfig.width, displayConfig.height,
+ displayConfig.dpiX, displayConfig.dpiY,
+ displayConfig.refreshRateHz, addDisplayToDeviceFn);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: failed to create display %d", __FUNCTION__, id);
+ return error;
+ }
+
+ ++id;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error GuestComposer::createDisplay(
+ Device* device, uint32_t id, uint32_t width, uint32_t height, uint32_t dpiX,
+ uint32_t dpiY, uint32_t refreshRateHz,
+ const AddDisplayToDeviceFunction& addDisplayToDeviceFn) {
+ auto display = std::make_unique<Display>(*device, this, id);
+ if (display == nullptr) {
+ ALOGE("%s failed to allocate display", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+ auto displayId = display->getId();
+
+ HWC2::Error error = display->init(width, height, dpiX, dpiY, refreshRateHz);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize display:%" PRIu64, __FUNCTION__, displayId);
+ return error;
+ }
+
+ auto it = mDisplayInfos.find(displayId);
+ if (it != mDisplayInfos.end()) {
+ ALOGE("%s: display:%" PRIu64 " already created?", __FUNCTION__, displayId);
+ }
+
+ GuestComposerDisplayInfo& displayInfo = mDisplayInfos[displayId];
+
+ uint32_t bufferStride;
+ buffer_handle_t bufferHandle;
+
+ auto status = GraphicBufferAllocator::get().allocate(
+ width, //
+ height, //
+ PIXEL_FORMAT_RGBA_8888, //
+ /*layerCount=*/1, //
+ GraphicBuffer::USAGE_HW_COMPOSER | GraphicBuffer::USAGE_SW_READ_OFTEN |
+ GraphicBuffer::USAGE_SW_WRITE_OFTEN, //
+ &bufferHandle, //
+ &bufferStride, //
+ "RanchuHwc");
+ if (status != OK) {
+ ALOGE("%s failed to allocate composition buffer for display:%" PRIu64,
+ __FUNCTION__, displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ displayInfo.compositionResultBuffer = bufferHandle;
+
+ displayInfo.compositionResultDrmBuffer = std::make_unique<DrmBuffer>(
+ displayInfo.compositionResultBuffer, mDrmPresenter);
+
+ if (displayId == 0) {
+ int flushSyncFd = -1;
+
+ HWC2::Error flushError =
+ displayInfo.compositionResultDrmBuffer->flushToDisplay(displayId,
+ &flushSyncFd);
+ if (flushError != HWC2::Error::None) {
+ ALOGW(
+ "%s: Initial display flush failed. HWComposer assuming that we are "
+ "running in QEMU without a display and disabling presenting.",
+ __FUNCTION__);
+ mPresentDisabled = true;
+ } else {
+ close(flushSyncFd);
+ }
+ }
+
+ error = addDisplayToDeviceFn(std::move(display));
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to add display:%" PRIu64, __FUNCTION__, displayId);
+ return error;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error GuestComposer::onDisplayDestroy(Display* display) {
+ auto displayId = display->getId();
+
+ auto it = mDisplayInfos.find(displayId);
+ if (it == mDisplayInfos.end()) {
+ ALOGE("%s: display:%" PRIu64 " missing display buffers?", __FUNCTION__,
+ displayId);
+ return HWC2::Error::BadDisplay;
+ }
+
+ GuestComposerDisplayInfo& displayInfo = mDisplayInfos[displayId];
+
+ GraphicBufferAllocator::get().free(displayInfo.compositionResultBuffer);
+
+ mDisplayInfos.erase(it);
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error GuestComposer::getDisplayConfigsFromDeviceConfig(
+ std::vector<GuestComposer::DisplayConfig>* configs) {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ const auto deviceConfig = cuttlefish::GetDeviceConfig();
+ for (const auto& deviceDisplayConfig : deviceConfig.display_config()) {
+ DisplayConfig displayConfig = {
+ .width = deviceDisplayConfig.width(),
+ .height = deviceDisplayConfig.height(),
+ .dpiX = deviceDisplayConfig.dpi(),
+ .dpiY = deviceDisplayConfig.dpi(),
+ .refreshRateHz = deviceDisplayConfig.refresh_rate_hz(),
+ };
+
+ configs->push_back(displayConfig);
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error GuestComposer::getDisplayConfigsFromSystemProp(
+ std::vector<GuestComposer::DisplayConfig>* configs) {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ static constexpr const char kExternalDisplayProp[] =
+ "hwservicemanager.external.displays";
+
+ const auto propString = android::base::GetProperty(kExternalDisplayProp, "");
+ DEBUG_LOG("%s: prop value is: %s", __FUNCTION__, propString.c_str());
+
+ if (propString.empty()) {
+ return HWC2::Error::None;
+ }
+
+ const std::vector<std::string> propStringParts =
+ android::base::Split(propString, ",");
+ if (propStringParts.size() % 5 != 0) {
+ ALOGE("%s: Invalid syntax for system prop %s which is %s", __FUNCTION__,
+ kExternalDisplayProp, propString.c_str());
+ return HWC2::Error::BadParameter;
+ }
+
+ std::vector<int> propIntParts;
+ for (const std::string& propStringPart : propStringParts) {
+ int propIntPart;
+ if (!android::base::ParseInt(propStringPart, &propIntPart)) {
+ ALOGE("%s: Invalid syntax for system prop %s which is %s", __FUNCTION__,
+ kExternalDisplayProp, propString.c_str());
+ return HWC2::Error::BadParameter;
+ }
+ propIntParts.push_back(propIntPart);
+ }
+
+ while (!propIntParts.empty()) {
+ DisplayConfig display_config = {
+ .width = propIntParts[1],
+ .height = propIntParts[2],
+ .dpiX = propIntParts[3],
+ .dpiY = propIntParts[3],
+ .refreshRateHz = 160,
+ };
+
+ configs->push_back(display_config);
+
+ propIntParts.erase(propIntParts.begin(), propIntParts.begin() + 5);
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error GuestComposer::validateDisplay(
+ Display* display, std::unordered_map<hwc2_layer_t, HWC2::Composition>*
+ outLayerCompositionChanges) {
+ const auto displayId = display->getId();
+ DEBUG_LOG("%s display:%" PRIu64, __FUNCTION__, displayId);
+
+ const std::vector<Layer*>& layers = display->getOrderedLayers();
+
+ bool fallbackToClientComposition = false;
+ for (Layer* layer : layers) {
+ const auto layerId = layer->getId();
+ const auto layerCompositionType = layer->getCompositionType();
+ const auto layerCompositionTypeString = to_string(layerCompositionType);
+
+ if (layerCompositionType == HWC2::Composition::Invalid) {
+ ALOGE("%s display:%" PRIu64 " layer:%" PRIu64 " has Invalid composition",
+ __FUNCTION__, displayId, layerId);
+ continue;
+ }
+
+ if (layerCompositionType == HWC2::Composition::Client ||
+ layerCompositionType == HWC2::Composition::Cursor ||
+ layerCompositionType == HWC2::Composition::Sideband ||
+ layerCompositionType == HWC2::Composition::SolidColor) {
+ ALOGW("%s: display:%" PRIu64 " layer:%" PRIu64
+ " has composition type %s, falling back to client composition",
+ __FUNCTION__, displayId, layerId,
+ layerCompositionTypeString.c_str());
+ fallbackToClientComposition = true;
+ break;
+ }
+
+ if (!canComposeLayer(layer)) {
+ ALOGW("%s: display:%" PRIu64 " layer:%" PRIu64
+ " composition not supported, falling back to client composition",
+ __FUNCTION__, displayId, layerId);
+ fallbackToClientComposition = true;
+ break;
+ }
+ }
+
+ if (fallbackToClientComposition) {
+ for (Layer* layer : layers) {
+ const auto layerId = layer->getId();
+ const auto layerCompositionType = layer->getCompositionType();
+
+ if (layerCompositionType == HWC2::Composition::Invalid) {
+ continue;
+ }
+ if (layerCompositionType != HWC2::Composition::Client) {
+ DEBUG_LOG("%s display:%" PRIu64 " layer:%" PRIu64
+ "composition updated to Client",
+ __FUNCTION__, displayId, layerId);
+ (*outLayerCompositionChanges)[layerId] = HWC2::Composition::Client;
+ }
+ }
+ }
+
+ // We can not draw below a Client (SurfaceFlinger) composed layer. Change all
+ // layers below a Client composed layer to also be Client composed.
+ if (layers.size() > 1) {
+ for (std::size_t layerIndex = layers.size() - 1; layerIndex > 0;
+ layerIndex--) {
+ auto layer = layers[layerIndex];
+ auto layerCompositionType = layer->getCompositionType();
+
+ if (layerCompositionType == HWC2::Composition::Client) {
+ for (std::size_t lowerLayerIndex = 0; lowerLayerIndex < layerIndex;
+ lowerLayerIndex++) {
+ auto lowerLayer = layers[lowerLayerIndex];
+ auto lowerLayerId = lowerLayer->getId();
+ auto lowerLayerCompositionType = lowerLayer->getCompositionType();
+
+ if (lowerLayerCompositionType != HWC2::Composition::Client) {
+ DEBUG_LOG("%s: display:%" PRIu64 " changing layer:%" PRIu64
+ " to Client because"
+ "hwcomposer can not draw below the Client composed "
+ "layer:%" PRIu64,
+ __FUNCTION__, displayId, lowerLayerId, layer->getId());
+
+ (*outLayerCompositionChanges)[lowerLayerId] =
+ HWC2::Composition::Client;
+ }
+ }
+ }
+ }
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error GuestComposer::presentDisplay(Display* display,
+ int32_t* outRetireFence) {
+ const auto displayId = display->getId();
+ DEBUG_LOG("%s display:%" PRIu64, __FUNCTION__, displayId);
+
+ if (displayId != 0) {
+ // TODO(b/171305898): remove after multi-display fully supported.
+ return HWC2::Error::None;
+ }
+
+ if (mPresentDisabled) {
+ return HWC2::Error::None;
+ }
+
+ auto it = mDisplayInfos.find(displayId);
+ if (it == mDisplayInfos.end()) {
+ ALOGE("%s: display:%" PRIu64 " not found", __FUNCTION__, displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ GuestComposerDisplayInfo& displayInfo = it->second;
+
+ if (displayInfo.compositionResultBuffer == nullptr) {
+ ALOGE("%s: display:%" PRIu64 " missing composition result buffer",
+ __FUNCTION__, displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ std::optional<GrallocBuffer> compositionResultBufferOpt =
+ mGralloc.Import(displayInfo.compositionResultBuffer);
+ if (!compositionResultBufferOpt) {
+ ALOGE("%s: display:%" PRIu64 " failed to import buffer", __FUNCTION__,
+ displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ std::optional<uint32_t> compositionResultBufferWidthOpt =
+ compositionResultBufferOpt->GetWidth();
+ if (!compositionResultBufferWidthOpt) {
+ ALOGE("%s: display:%" PRIu64 " failed to query buffer width", __FUNCTION__,
+ displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ std::optional<uint32_t> compositionResultBufferHeightOpt =
+ compositionResultBufferOpt->GetHeight();
+ if (!compositionResultBufferHeightOpt) {
+ ALOGE("%s: display:%" PRIu64 " failed to query buffer height", __FUNCTION__,
+ displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ std::optional<uint32_t> compositionResultBufferStrideOpt =
+ compositionResultBufferOpt->GetMonoPlanarStrideBytes();
+ if (!compositionResultBufferStrideOpt) {
+ ALOGE("%s: display:%" PRIu64 " failed to query buffer stride", __FUNCTION__,
+ displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ std::optional<GrallocBufferView> compositionResultBufferViewOpt =
+ compositionResultBufferOpt->Lock();
+ if (!compositionResultBufferViewOpt) {
+ ALOGE("%s: display:%" PRIu64 " failed to get buffer view", __FUNCTION__,
+ displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ const std::optional<void*> compositionResultBufferDataOpt =
+ compositionResultBufferViewOpt->Get();
+ if (!compositionResultBufferDataOpt) {
+ ALOGE("%s: display:%" PRIu64 " failed to get buffer data", __FUNCTION__,
+ displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ uint32_t compositionResultBufferWidth = *compositionResultBufferWidthOpt;
+ uint32_t compositionResultBufferHeight = *compositionResultBufferHeightOpt;
+ uint32_t compositionResultBufferStride = *compositionResultBufferStrideOpt;
+ uint8_t* compositionResultBufferData =
+ reinterpret_cast<uint8_t*>(*compositionResultBufferDataOpt);
+
+ const std::vector<Layer*>& layers = display->getOrderedLayers();
+
+ const bool noOpComposition = layers.empty();
+ const bool allLayersClientComposed = std::all_of(
+ layers.begin(), //
+ layers.end(), //
+ [](const Layer* layer) {
+ return layer->getCompositionType() == HWC2::Composition::Client;
+ });
+
+ if (noOpComposition) {
+ ALOGW("%s: display:%" PRIu64 " empty composition", __FUNCTION__, displayId);
+ } else if (allLayersClientComposed) {
+ auto clientTargetBufferOpt =
+ mGralloc.Import(display->waitAndGetClientTargetBuffer());
+ if (!clientTargetBufferOpt) {
+ ALOGE("%s: failed to import client target buffer.", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+ GrallocBuffer& clientTargetBuffer = *clientTargetBufferOpt;
+
+ auto clientTargetBufferViewOpt = clientTargetBuffer.Lock();
+ if (!clientTargetBufferViewOpt) {
+ ALOGE("%s: failed to lock client target buffer.", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+ GrallocBufferView& clientTargetBufferView = *clientTargetBufferViewOpt;
+
+ auto clientTargetPlaneLayoutsOpt = clientTargetBuffer.GetPlaneLayouts();
+ if (!clientTargetPlaneLayoutsOpt) {
+ ALOGE("Failed to get client target buffer plane layouts.");
+ return HWC2::Error::NoResources;
+ }
+ auto& clientTargetPlaneLayouts = *clientTargetPlaneLayoutsOpt;
+
+ if (clientTargetPlaneLayouts.size() != 1) {
+ ALOGE("Unexpected number of plane layouts for client target buffer.");
+ return HWC2::Error::NoResources;
+ }
+
+ std::size_t clientTargetPlaneSize =
+ clientTargetPlaneLayouts[0].totalSizeInBytes;
+
+ auto clientTargetDataOpt = clientTargetBufferView.Get();
+ if (!clientTargetDataOpt) {
+ ALOGE("%s failed to lock gralloc buffer.", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+ auto* clientTargetData = reinterpret_cast<uint8_t*>(*clientTargetDataOpt);
+
+ std::memcpy(compositionResultBufferData, clientTargetData,
+ clientTargetPlaneSize);
+ } else {
+ for (Layer* layer : layers) {
+ const auto layerId = layer->getId();
+ const auto layerCompositionType = layer->getCompositionType();
+ if (layerCompositionType != HWC2::Composition::Device) {
+ continue;
+ }
+
+ HWC2::Error error = composeLayerInto(layer, //
+ compositionResultBufferData, //
+ compositionResultBufferWidth, //
+ compositionResultBufferHeight, //
+ compositionResultBufferStride, //
+ 4);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to compose layer:%" PRIu64,
+ __FUNCTION__, displayId, layerId);
+ return error;
+ }
+ }
+ }
+
+ if (display->hasColorTransform()) {
+ const ColorTransformWithMatrix colorTransform =
+ display->getColorTransform();
+
+ HWC2::Error error =
+ applyColorTransformToRGBA(colorTransform, //
+ compositionResultBufferData, //
+ compositionResultBufferWidth, //
+ compositionResultBufferHeight, //
+ compositionResultBufferStride);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to apply color transform",
+ __FUNCTION__, displayId);
+ return error;
+ }
+ }
+
+ DEBUG_LOG("%s display:%" PRIu64 " flushing drm buffer", __FUNCTION__,
+ displayId);
+
+ HWC2::Error error = displayInfo.compositionResultDrmBuffer->flushToDisplay(
+ static_cast<int>(displayId), outRetireFence);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to flush drm buffer" PRIu64,
+ __FUNCTION__, displayId);
+ }
+ return error;
+}
+
+bool GuestComposer::canComposeLayer(Layer* layer) {
+ buffer_handle_t bufferHandle = layer->getBuffer().getBuffer();
+ if (bufferHandle == nullptr) {
+ ALOGW("%s received a layer with a null handle", __FUNCTION__);
+ return false;
+ }
+
+ auto bufferOpt = mGralloc.Import(bufferHandle);
+ if (!bufferOpt) {
+ ALOGE("Failed to import layer buffer.");
+ return false;
+ }
+ GrallocBuffer& buffer = *bufferOpt;
+
+ auto bufferFormatOpt = buffer.GetDrmFormat();
+ if (!bufferFormatOpt) {
+ ALOGE("Failed to get layer buffer format.");
+ return false;
+ }
+ uint32_t bufferFormat = *bufferFormatOpt;
+
+ if (!IsDrmFormatSupported(bufferFormat)) {
+ return false;
+ }
+
+ return true;
+}
+
+HWC2::Error GuestComposer::composeLayerInto(
+ Layer* srcLayer, std::uint8_t* dstBuffer, std::uint32_t dstBufferWidth,
+ std::uint32_t dstBufferHeight, std::uint32_t dstBufferStrideBytes,
+ std::uint32_t dstBufferBytesPerPixel) {
+ libyuv::RotationMode rotation =
+ GetRotationFromTransform(srcLayer->getTransform());
+
+ auto srcBufferOpt = mGralloc.Import(srcLayer->waitAndGetBuffer());
+ if (!srcBufferOpt) {
+ ALOGE("%s: failed to import layer buffer.", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+ GrallocBuffer& srcBuffer = *srcBufferOpt;
+
+ auto srcBufferViewOpt = srcBuffer.Lock();
+ if (!srcBufferViewOpt) {
+ ALOGE("%s: failed to lock import layer buffer.", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+ GrallocBufferView& srcBufferView = *srcBufferViewOpt;
+
+ hwc_rect_t srcLayerCrop = srcLayer->getSourceCropInt();
+ hwc_rect_t srcLayerDisplayFrame = srcLayer->getDisplayFrame();
+
+ auto srcLayerSpecOpt = GetBufferSpec(srcBuffer, srcBufferView, srcLayerCrop);
+ if (!srcLayerSpecOpt) {
+ return HWC2::Error::NoResources;
+ }
+ BufferSpec srcLayerSpec = *srcLayerSpecOpt;
+
+ // TODO(jemoreira): Remove the hardcoded fomat.
+ bool needsConversion = srcLayerSpec.drmFormat != DRM_FORMAT_XBGR8888;
+ bool needsScaling = LayerNeedsScaling(*srcLayer);
+ bool needsRotation = rotation != libyuv::kRotate0;
+ bool needsTranspose = needsRotation && rotation != libyuv::kRotate180;
+ bool needsVFlip = GetVFlipFromTransform(srcLayer->getTransform());
+ bool needsAttenuation = LayerNeedsAttenuation(*srcLayer);
+ bool needsBlending = LayerNeedsBlending(*srcLayer);
+ bool needsCopy = !(needsConversion || needsScaling || needsRotation ||
+ needsVFlip || needsAttenuation || needsBlending);
+
+ BufferSpec dstLayerSpec(
+ dstBuffer,
+ /*buffer_ycbcr=*/std::nullopt, dstBufferWidth, dstBufferHeight,
+ srcLayerDisplayFrame.left, srcLayerDisplayFrame.top,
+ srcLayerDisplayFrame.right - srcLayerDisplayFrame.left,
+ srcLayerDisplayFrame.bottom - srcLayerDisplayFrame.top,
+ DRM_FORMAT_XBGR8888, dstBufferStrideBytes, dstBufferBytesPerPixel);
+
+ // Add the destination layer to the bottom of the buffer stack
+ std::vector<BufferSpec> dstBufferStack(1, dstLayerSpec);
+
+ // If more than operation is to be performed, a temporary buffer is needed for
+ // each additional operation
+
+ // N operations need N destination buffers, the destination layer (the
+ // framebuffer) is one of them, so only N-1 temporary buffers are needed.
+ // Vertical flip is not taken into account because it can be done together
+ // with any other operation.
+ int neededScratchBuffers = (needsConversion ? 1 : 0) +
+ (needsScaling ? 1 : 0) + (needsRotation ? 1 : 0) +
+ (needsAttenuation ? 1 : 0) +
+ (needsBlending ? 1 : 0) + (needsCopy ? 1 : 0) - 1;
+
+ int mScratchBufferWidth =
+ srcLayerDisplayFrame.right - srcLayerDisplayFrame.left;
+ int mScratchBufferHeight =
+ srcLayerDisplayFrame.bottom - srcLayerDisplayFrame.top;
+ int mScratchBufferStrideBytes =
+ AlignToPower2(mScratchBufferWidth * dstBufferBytesPerPixel, 4);
+ int mScratchBufferSizeBytes =
+ mScratchBufferHeight * mScratchBufferStrideBytes;
+
+ for (int i = 0; i < neededScratchBuffers; i++) {
+ BufferSpec mScratchBufferspec(
+ getRotatingScratchBuffer(mScratchBufferSizeBytes, i),
+ mScratchBufferWidth, mScratchBufferHeight, mScratchBufferStrideBytes);
+ dstBufferStack.push_back(mScratchBufferspec);
+ }
+
+ // Conversion and scaling should always be the first operations, so that every
+ // other operation works on equally sized frames (guaranteed to fit in the
+ // scratch buffers).
+
+ // TODO(jemoreira): We are converting to ARGB as the first step under the
+ // assumption that scaling ARGB is faster than scaling I420 (the most common).
+ // This should be confirmed with testing.
+ if (needsConversion) {
+ BufferSpec& dstBufferSpec = dstBufferStack.back();
+ if (needsScaling || needsTranspose) {
+ // If a rotation or a scaling operation are needed the dimensions at the
+ // top of the buffer stack are wrong (wrong sizes for scaling, swapped
+ // width and height for 90 and 270 rotations).
+ // Make width and height match the crop sizes on the source
+ int srcWidth = srcLayerSpec.cropWidth;
+ int srcHeight = srcLayerSpec.cropHeight;
+ int dst_stride_bytes =
+ AlignToPower2(srcWidth * dstBufferBytesPerPixel, 4);
+ size_t needed_size = dst_stride_bytes * srcHeight;
+ dstBufferSpec.width = srcWidth;
+ dstBufferSpec.height = srcHeight;
+ // Adjust the stride accordingly
+ dstBufferSpec.strideBytes = dst_stride_bytes;
+ // Crop sizes also need to be adjusted
+ dstBufferSpec.cropWidth = srcWidth;
+ dstBufferSpec.cropHeight = srcHeight;
+ // cropX and y are fine at 0, format is already set to match destination
+
+ // In case of a scale, the source frame may be bigger than the default tmp
+ // buffer size
+ dstBufferSpec.buffer = getSpecialScratchBuffer(needed_size);
+ }
+
+ int retval = DoConversion(srcLayerSpec, dstBufferSpec, needsVFlip);
+ if (retval) {
+ ALOGE("Got error code %d from DoConversion function", retval);
+ }
+ needsVFlip = false;
+ srcLayerSpec = dstBufferSpec;
+ dstBufferStack.pop_back();
+ }
+
+ if (needsScaling) {
+ BufferSpec& dstBufferSpec = dstBufferStack.back();
+ if (needsTranspose) {
+ // If a rotation is needed, the temporary buffer has the correct size but
+ // needs to be transposed and have its stride updated accordingly. The
+ // crop sizes also needs to be transposed, but not the x and y since they
+ // are both zero in a temporary buffer (and it is a temporary buffer
+ // because a rotation will be performed next).
+ std::swap(dstBufferSpec.width, dstBufferSpec.height);
+ std::swap(dstBufferSpec.cropWidth, dstBufferSpec.cropHeight);
+ // TODO (jemoreira): Aligment (To align here may cause the needed size to
+ // be bigger than the buffer, so care should be taken)
+ dstBufferSpec.strideBytes = dstBufferSpec.width * dstBufferBytesPerPixel;
+ }
+ int retval = DoScaling(srcLayerSpec, dstBufferSpec, needsVFlip);
+ needsVFlip = false;
+ if (retval) {
+ ALOGE("Got error code %d from DoScaling function", retval);
+ }
+ srcLayerSpec = dstBufferSpec;
+ dstBufferStack.pop_back();
+ }
+
+ if (needsRotation) {
+ int retval =
+ DoRotation(srcLayerSpec, dstBufferStack.back(), rotation, needsVFlip);
+ needsVFlip = false;
+ if (retval) {
+ ALOGE("Got error code %d from DoTransform function", retval);
+ }
+ srcLayerSpec = dstBufferStack.back();
+ dstBufferStack.pop_back();
+ }
+
+ if (needsAttenuation) {
+ int retval = DoAttenuation(srcLayerSpec, dstBufferStack.back(), needsVFlip);
+ needsVFlip = false;
+ if (retval) {
+ ALOGE("Got error code %d from DoBlending function", retval);
+ }
+ srcLayerSpec = dstBufferStack.back();
+ dstBufferStack.pop_back();
+ }
+
+ if (needsCopy) {
+ int retval = DoCopy(srcLayerSpec, dstBufferStack.back(), needsVFlip);
+ needsVFlip = false;
+ if (retval) {
+ ALOGE("Got error code %d from DoBlending function", retval);
+ }
+ srcLayerSpec = dstBufferStack.back();
+ dstBufferStack.pop_back();
+ }
+
+ // Blending (if needed) should always be the last operation, so that it reads
+ // and writes in the destination layer and not some temporary buffer.
+ if (needsBlending) {
+ int retval = DoBlending(srcLayerSpec, dstBufferStack.back(), needsVFlip);
+ needsVFlip = false;
+ if (retval) {
+ ALOGE("Got error code %d from DoBlending function", retval);
+ }
+ // Don't need to assign destination to source in the last one
+ dstBufferStack.pop_back();
+ }
+
+ return HWC2::Error::None;
+}
+
+namespace {
+
+static constexpr const std::array<float, 16> kInvertColorMatrix = {
+ // clang-format off
+ -1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, -1.0f, 0.0f, 0.0f,
+ 0.0f, -1.0f, -1.0f, 0.0f,
+ 1.0f, 1.0f, 1.0f, 1.0f,
+ // clang-format on
+};
+
+// Returns a color matrix that can be used with libyuv by converting values
+// in -1 to 1 into -64 to 64 and transposing.
+std::array<std::int8_t, 16> ToLibyuvColorMatrix(
+ const std::array<float, 16>& in) {
+ std::array<std::int8_t, 16> out;
+
+ for (int r = 0; r < 4; r++) {
+ for (int c = 0; c < 4; c++) {
+ int indexIn = (4 * r) + c;
+ int indexOut = (4 * c) + r;
+
+ out[indexOut] = std::max(
+ -128, std::min(127, static_cast<int>(in[indexIn] * 64.0f + 0.5f)));
+ }
+ }
+
+ return out;
+}
+
+} // namespace
+
+HWC2::Error GuestComposer::applyColorTransformToRGBA(
+ const ColorTransformWithMatrix& transform, //
+ std::uint8_t* buffer, //
+ std::uint32_t bufferWidth, //
+ std::uint32_t bufferHeight, //
+ std::uint32_t bufferStrideBytes) {
+ if (transform.transformType == ColorTransform::ARBITRARY_MATRIX) {
+ if (!transform.transformMatrixOpt.has_value()) {
+ ALOGE("%s: color transform matrix missing", __FUNCTION__);
+ return HWC2::Error::BadParameter;
+ }
+ const auto& transformMatrix = *transform.transformMatrixOpt;
+ const auto transformMatrixLibyuv = ToLibyuvColorMatrix(transformMatrix);
+ libyuv::ARGBColorMatrix(buffer, bufferStrideBytes, // in buffer params
+ buffer, bufferStrideBytes, // out buffer params
+ transformMatrixLibyuv.data(), //
+ bufferWidth, //
+ bufferHeight);
+ } else if (transform.transformType == ColorTransform::VALUE_INVERSE) {
+ const auto transformMatrixLibyuv = ToLibyuvColorMatrix(kInvertColorMatrix);
+ libyuv::ARGBColorMatrix(buffer, bufferStrideBytes, // in buffer params
+ buffer, bufferStrideBytes, // out buffer params
+ transformMatrixLibyuv.data(), //
+ bufferWidth, //
+ bufferHeight);
+ } else if (transform.transformType == ColorTransform::GRAYSCALE) {
+ libyuv::ARGBGrayTo(buffer, bufferStrideBytes, // in buffer params
+ buffer, bufferStrideBytes, // out buffer params
+ bufferWidth, //
+ bufferHeight);
+ } else {
+ const auto transformTypeString = toString(transform.transformType);
+ ALOGE("%s: unhandled color transform type %s", __FUNCTION__,
+ transformTypeString.c_str());
+ return HWC2::Error::BadParameter;
+ }
+
+ return HWC2::Error::None;
+}
+
+uint8_t* GuestComposer::getRotatingScratchBuffer(std::size_t neededSize,
+ std::uint32_t order) {
+ static constexpr const int kNumScratchBufferPieces = 2;
+
+ std::size_t totalNeededSize = neededSize * kNumScratchBufferPieces;
+ if (mScratchBuffer.size() < totalNeededSize) {
+ mScratchBuffer.resize(totalNeededSize);
+ }
+
+ std::size_t bufferIndex = order % kNumScratchBufferPieces;
+ std::size_t bufferOffset = bufferIndex * neededSize;
+ return &mScratchBuffer[bufferOffset];
+}
+
+uint8_t* GuestComposer::getSpecialScratchBuffer(size_t neededSize) {
+ if (mSpecialScratchBuffer.size() < neededSize) {
+ mSpecialScratchBuffer.resize(neededSize);
+ }
+
+ return &mSpecialScratchBuffer[0];
+}
+
+} // namespace android
diff --git a/system/hwc2/GuestComposer.h b/system/hwc2/GuestComposer.h
new file mode 100644
index 0000000..8cc5d62
--- /dev/null
+++ b/system/hwc2/GuestComposer.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2021 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_GUESTCOMPOSER_H
+#define ANDROID_HWC_GUESTCOMPOSER_H
+
+#include "Common.h"
+#include "Composer.h"
+#include "Display.h"
+#include "DrmPresenter.h"
+#include "Gralloc.h"
+#include "Layer.h"
+
+namespace android {
+
+class GuestComposer : public Composer {
+ public:
+ GuestComposer() = default;
+
+ GuestComposer(const GuestComposer&) = delete;
+ GuestComposer& operator=(const GuestComposer&) = delete;
+
+ GuestComposer(GuestComposer&&) = delete;
+ GuestComposer& operator=(GuestComposer&&) = delete;
+
+ HWC2::Error init(const HotplugCallback& cb) override;
+
+ HWC2::Error createDisplays(
+ Device* device,
+ const AddDisplayToDeviceFunction& addDisplayToDeviceFn) override;
+
+ HWC2::Error createDisplay(
+ Device* device, uint32_t displayId, uint32_t width, uint32_t height,
+ uint32_t dpiX, uint32_t dpiY, uint32_t refreshRateHz,
+ const AddDisplayToDeviceFunction& addDisplayToDeviceFn) override;
+
+ HWC2::Error onDisplayDestroy(Display*) override;
+
+ HWC2::Error onDisplayClientTargetSet(Display*) override {
+ return HWC2::Error::None;
+ }
+
+ // Determines if this composer can compose the given layers on the given
+ // display and requests changes for layers that can't not be composed.
+ HWC2::Error validateDisplay(
+ Display* display, std::unordered_map<hwc2_layer_t, HWC2::Composition>*
+ outLayerCompositionChanges) override;
+
+ // Performs the actual composition of layers and presents the composed result
+ // to the display.
+ HWC2::Error presentDisplay(Display* display,
+ int32_t* outPresentFence) override;
+
+ private:
+ struct DisplayConfig {
+ int width;
+ int height;
+ int dpiX;
+ int dpiY;
+ int refreshRateHz;
+ };
+
+ HWC2::Error getDisplayConfigsFromDeviceConfig(
+ std::vector<DisplayConfig>* configs);
+
+ HWC2::Error getDisplayConfigsFromSystemProp(
+ std::vector<DisplayConfig>* configs);
+
+ // Returns true if the given layer's buffer has supported format.
+ bool canComposeLayer(Layer* layer);
+
+ // Composes the given layer into the given destination buffer.
+ HWC2::Error composeLayerInto(Layer* layer, std::uint8_t* dstBuffer,
+ std::uint32_t dstBufferWidth,
+ std::uint32_t dstBufferHeight,
+ std::uint32_t dstBufferStrideBytes,
+ std::uint32_t dstBufferBytesPerPixel);
+
+ struct GuestComposerDisplayInfo {
+ // Additional per display buffer for the composition result.
+ buffer_handle_t compositionResultBuffer = nullptr;
+
+ std::unique_ptr<DrmBuffer> compositionResultDrmBuffer;
+ };
+
+ std::unordered_map<hwc2_display_t, GuestComposerDisplayInfo> mDisplayInfos;
+
+ Gralloc mGralloc;
+
+ DrmPresenter mDrmPresenter;
+
+ // Cuttlefish on QEMU does not have a display. Disable presenting to avoid
+ // spamming logcat with DRM commit failures.
+ bool mPresentDisabled = false;
+
+ uint8_t* getRotatingScratchBuffer(std::size_t neededSize,
+ std::uint32_t order);
+ uint8_t* getSpecialScratchBuffer(std::size_t neededSize);
+
+ HWC2::Error applyColorTransformToRGBA(
+ const ColorTransformWithMatrix& colotTransform, //
+ std::uint8_t* buffer,//
+ std::uint32_t bufferWidth,//
+ std::uint32_t bufferHeight,//
+ std::uint32_t bufferStrideBytes);
+
+ std::vector<uint8_t> mScratchBuffer;
+ std::vector<uint8_t> mSpecialScratchBuffer;
+};
+
+} // namespace android
+
+#endif
diff --git a/system/hwc2/HostComposer.cpp b/system/hwc2/HostComposer.cpp
new file mode 100644
index 0000000..c55eccd
--- /dev/null
+++ b/system/hwc2/HostComposer.cpp
@@ -0,0 +1,858 @@
+/*
+ * Copyright 2021 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 "HostComposer.h"
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <android-base/parseint.h>
+#include <android-base/properties.h>
+#include <android-base/strings.h>
+#include <drm/virtgpu_drm.h>
+#include <poll.h>
+#include <sync/sync.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/GraphicBufferAllocator.h>
+#include <ui/GraphicBufferMapper.h>
+
+#include "../egl/goldfish_sync.h"
+#include "Device.h"
+#include "Display.h"
+
+namespace android {
+namespace {
+
+static int getVsyncHzFromProperty() {
+ static constexpr const auto kVsyncProp = "ro.boot.qemu.vsync";
+
+ const auto vsyncProp = android::base::GetProperty(kVsyncProp, "");
+ DEBUG_LOG("%s: prop value is: %s", __FUNCTION__, vsyncProp.c_str());
+
+ uint64_t vsyncPeriod;
+ if (!android::base::ParseUint(vsyncProp, &vsyncPeriod)) {
+ ALOGE("%s: failed to parse vsync period '%s', returning default 60",
+ __FUNCTION__, vsyncProp.c_str());
+ return 60;
+ }
+
+ return static_cast<int>(vsyncPeriod);
+}
+
+static bool isMinigbmFromProperty() {
+ static constexpr const auto kGrallocProp = "ro.hardware.gralloc";
+
+ const auto grallocProp = android::base::GetProperty(kGrallocProp, "");
+ DEBUG_LOG("%s: prop value is: %s", __FUNCTION__, grallocProp.c_str());
+
+ if (grallocProp == "minigbm") {
+ ALOGD("%s: Using minigbm, in minigbm mode.\n", __FUNCTION__);
+ return true;
+ } else {
+ ALOGD("%s: Is not using minigbm, in goldfish mode.\n", __FUNCTION__);
+ return false;
+ }
+}
+
+#define DEFINE_AND_VALIDATE_HOST_CONNECTION \
+ HostConnection* hostCon = createOrGetHostConnection(); \
+ if (!hostCon) { \
+ ALOGE("%s: Failed to get host connection\n", __FUNCTION__); \
+ return HWC2::Error::NoResources; \
+ } \
+ ExtendedRCEncoderContext* rcEnc = hostCon->rcEncoder(); \
+ if (!rcEnc) { \
+ ALOGE("%s: Failed to get renderControl encoder context\n", __FUNCTION__); \
+ return HWC2::Error::NoResources; \
+ }
+
+static std::unique_ptr<HostConnection> sHostCon;
+
+static HostConnection* createOrGetHostConnection() {
+ if (!sHostCon) {
+ sHostCon = HostConnection::createUnique();
+ }
+ return sHostCon.get();
+}
+
+typedef struct compose_layer {
+ uint32_t cbHandle;
+ hwc2_composition_t composeMode;
+ hwc_rect_t displayFrame;
+ hwc_frect_t crop;
+ int32_t blendMode;
+ float alpha;
+ hwc_color_t color;
+ hwc_transform_t transform;
+} ComposeLayer;
+
+typedef struct compose_device {
+ uint32_t version;
+ uint32_t targetHandle;
+ uint32_t numLayers;
+ struct compose_layer layer[0];
+} ComposeDevice;
+
+typedef struct compose_device_v2 {
+ uint32_t version;
+ uint32_t displayId;
+ uint32_t targetHandle;
+ uint32_t numLayers;
+ struct compose_layer layer[0];
+} ComposeDevice_v2;
+
+class ComposeMsg {
+ public:
+ ComposeMsg(uint32_t layerCnt = 0)
+ : mData(sizeof(ComposeDevice) + layerCnt * sizeof(ComposeLayer)) {
+ mComposeDevice = reinterpret_cast<ComposeDevice*>(mData.data());
+ mLayerCnt = layerCnt;
+ }
+
+ ComposeDevice* get() { return mComposeDevice; }
+
+ uint32_t getLayerCnt() { return mLayerCnt; }
+
+ private:
+ std::vector<uint8_t> mData;
+ uint32_t mLayerCnt;
+ ComposeDevice* mComposeDevice;
+};
+
+class ComposeMsg_v2 {
+ public:
+ ComposeMsg_v2(uint32_t layerCnt = 0)
+ : mData(sizeof(ComposeDevice_v2) + layerCnt * sizeof(ComposeLayer)) {
+ mComposeDevice = reinterpret_cast<ComposeDevice_v2*>(mData.data());
+ mLayerCnt = layerCnt;
+ }
+
+ ComposeDevice_v2* get() { return mComposeDevice; }
+
+ uint32_t getLayerCnt() { return mLayerCnt; }
+
+ private:
+ std::vector<uint8_t> mData;
+ uint32_t mLayerCnt;
+ ComposeDevice_v2* mComposeDevice;
+};
+
+const native_handle_t* AllocateDisplayColorBuffer(int width, int height) {
+ const uint32_t layerCount = 1;
+ const uint64_t graphicBufferId = 0; // not used
+ buffer_handle_t h;
+ uint32_t stride;
+
+ if (GraphicBufferAllocator::get().allocate(
+ width, height, PIXEL_FORMAT_RGBA_8888, layerCount,
+ (GraphicBuffer::USAGE_HW_COMPOSER | GraphicBuffer::USAGE_HW_RENDER),
+ &h, &stride, graphicBufferId, "EmuHWC2") == OK) {
+ return static_cast<const native_handle_t*>(h);
+ } else {
+ return nullptr;
+ }
+}
+
+void FreeDisplayColorBuffer(const native_handle_t* h) {
+ GraphicBufferAllocator::get().free(h);
+}
+
+} // namespace
+
+HWC2::Error HostComposer::init(const HotplugCallback& cb) {
+ mIsMinigbm = isMinigbmFromProperty();
+ if (mIsMinigbm) {
+ if (!mDrmPresenter.init(cb)) {
+ ALOGE("%s: failed to initialize DrmPresenter", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+ } else {
+ mSyncDeviceFd = goldfish_sync_open();
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::createDisplays(
+ Device* device, const AddDisplayToDeviceFunction& addDisplayToDeviceFn) {
+ HWC2::Error error = HWC2::Error::None;
+
+ error = createPrimaryDisplay(device, addDisplayToDeviceFn);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to create primary display", __FUNCTION__);
+ return error;
+ }
+
+ error = createSecondaryDisplays(device, addDisplayToDeviceFn);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to create secondary displays", __FUNCTION__);
+ return error;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::createPrimaryDisplay(
+ Device* device, const AddDisplayToDeviceFunction& addDisplayToDeviceFn) {
+ HWC2::Error error = HWC2::Error::None;
+
+ DEFINE_AND_VALIDATE_HOST_CONNECTION
+ hostCon->lock();
+ int width = rcEnc->rcGetFBParam(rcEnc, FB_WIDTH);
+ int height = rcEnc->rcGetFBParam(rcEnc, FB_HEIGHT);
+ int dpiX = rcEnc->rcGetFBParam(rcEnc, FB_XDPI);
+ int dpiY = rcEnc->rcGetFBParam(rcEnc, FB_YDPI);
+ hostCon->unlock();
+
+ int refreshRateHz = getVsyncHzFromProperty();
+
+ auto display = std::make_unique<Display>(*device, this, 0);
+ if (display == nullptr) {
+ ALOGE("%s failed to allocate display", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+ auto displayId = display->getId();
+
+ error = display->init(width, height, dpiX, dpiY, refreshRateHz);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize display:%" PRIu64, __FUNCTION__, displayId);
+ return error;
+ }
+
+ error = createHostComposerDisplayInfo(display.get(), /*hostDisplayId=*/0);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize host info for display:%" PRIu64,
+ __FUNCTION__, displayId);
+ return error;
+ }
+
+ error = addDisplayToDeviceFn(std::move(display));
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to add display:%" PRIu64, __FUNCTION__, displayId);
+ return error;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::createDisplay(
+ Device* device, uint32_t displayId, uint32_t width, uint32_t height,
+ uint32_t dpiX, uint32_t dpiY, uint32_t refreshRateHz,
+ const AddDisplayToDeviceFunction& addDisplayToDeviceFn) {
+ HWC2::Error error;
+ Display* display = device->getDisplay(displayId);
+ if (display) {
+ ALOGD("%s display %d already existed, then update", __func__, displayId);
+ }
+
+ DEFINE_AND_VALIDATE_HOST_CONNECTION
+ hostCon->lock();
+ if (rcEnc->rcCreateDisplayById(rcEnc, displayId)) {
+ ALOGE("%s host failed to create display %" PRIu32, __func__, displayId);
+ hostCon->unlock();
+ return HWC2::Error::NoResources;
+ }
+ if (rcEnc->rcSetDisplayPoseDpi(rcEnc, displayId, -1, -1, width, height, dpiX/1000)) {
+ ALOGE("%s host failed to set display %" PRIu32, __func__, displayId);
+ hostCon->unlock();
+ return HWC2::Error::NoResources;
+ }
+ hostCon->unlock();
+
+ std::optional<std::vector<uint8_t>> edid;
+ if (mIsMinigbm) {
+ edid = mDrmPresenter.getEdid(displayId);
+ }
+ if (!display) {
+ auto newDisplay = std::make_unique<Display>(*device, this, displayId);
+ if (newDisplay == nullptr) {
+ ALOGE("%s failed to allocate display", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+
+ error = newDisplay->init(width, height, dpiX, dpiY, refreshRateHz, edid);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize display:%" PRIu32, __FUNCTION__,
+ displayId);
+ return error;
+ }
+
+ error =
+ createHostComposerDisplayInfo(newDisplay.get(), displayId);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize host info for display:%" PRIu32,
+ __FUNCTION__, displayId);
+ return error;
+ }
+
+ error = addDisplayToDeviceFn(std::move(newDisplay));
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to add display:%" PRIu32, __FUNCTION__, displayId);
+ return error;
+ }
+ } else {
+ display->lock();
+ // update display parameters
+ error = display->updateParameters(width, height, dpiX, dpiY,
+ refreshRateHz, edid);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to update display:%" PRIu32, __FUNCTION__, displayId);
+ display->unlock();
+ return error;
+ }
+
+ error = createHostComposerDisplayInfo(display, displayId);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize host info for display:%" PRIu32,
+ __FUNCTION__, displayId);
+ display->unlock();
+ return error;
+ }
+ display->unlock();
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::createSecondaryDisplays(
+ Device* device, const AddDisplayToDeviceFunction& addDisplayToDeviceFn) {
+ HWC2::Error error = HWC2::Error::None;
+
+ static constexpr const char kExternalDisplayProp[] =
+ "hwservicemanager.external.displays";
+
+ const auto propString = android::base::GetProperty(kExternalDisplayProp, "");
+ DEBUG_LOG("%s: prop value is: %s", __FUNCTION__, propString.c_str());
+
+ if (propString.empty()) {
+ return HWC2::Error::None;
+ }
+
+ const std::vector<std::string> propStringParts =
+ android::base::Split(propString, ",");
+ if (propStringParts.size() % 5 != 0) {
+ ALOGE("%s: Invalid syntax for system prop %s which is %s", __FUNCTION__,
+ kExternalDisplayProp, propString.c_str());
+ return HWC2::Error::BadParameter;
+ }
+
+ std::vector<int> propIntParts;
+ for (const std::string& propStringPart : propStringParts) {
+ uint64_t propUintPart;
+ if (!android::base::ParseUint(propStringPart, &propUintPart)) {
+ ALOGE("%s: Invalid syntax for system prop %s which is %s", __FUNCTION__,
+ kExternalDisplayProp, propString.c_str());
+ return HWC2::Error::BadParameter;
+ }
+ propIntParts.push_back(static_cast<int>(propUintPart));
+ }
+
+ static constexpr const uint32_t kHostDisplayIdStart = 6;
+
+ uint32_t secondaryDisplayIndex = 1;
+ while (!propIntParts.empty()) {
+ int width = propIntParts[1];
+ int height = propIntParts[2];
+ int dpiX = propIntParts[3];
+ int dpiY = propIntParts[3];
+ int refreshRateHz = 160;
+
+ propIntParts.erase(propIntParts.begin(), propIntParts.begin() + 5);
+
+ uint32_t expectedHostDisplayId =
+ kHostDisplayIdStart + secondaryDisplayIndex - 1;
+ uint32_t actualHostDisplayId = 0;
+
+ DEFINE_AND_VALIDATE_HOST_CONNECTION
+ hostCon->lock();
+ rcEnc->rcDestroyDisplay(rcEnc, expectedHostDisplayId);
+ rcEnc->rcCreateDisplay(rcEnc, &actualHostDisplayId);
+ rcEnc->rcSetDisplayPose(rcEnc, actualHostDisplayId, -1, -1, width, height);
+ hostCon->unlock();
+
+ if (actualHostDisplayId != expectedHostDisplayId) {
+ ALOGE(
+ "Something wrong with host displayId allocation, expected %d "
+ "but received %d",
+ expectedHostDisplayId, actualHostDisplayId);
+ }
+
+ auto display =
+ std::make_unique<Display>(*device, this, secondaryDisplayIndex++);
+ if (display == nullptr) {
+ ALOGE("%s failed to allocate display", __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+
+ auto displayId = display->getId();
+
+ error = display->init(width, height, dpiX, dpiY, refreshRateHz);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize display:%" PRIu64, __FUNCTION__,
+ displayId);
+ return error;
+ }
+
+ error = createHostComposerDisplayInfo(display.get(), actualHostDisplayId);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to initialize host info for display:%" PRIu64,
+ __FUNCTION__, displayId);
+ return error;
+ }
+
+ error = addDisplayToDeviceFn(std::move(display));
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to add display:%" PRIu64, __FUNCTION__, displayId);
+ return error;
+ }
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::createHostComposerDisplayInfo(
+ Display* display, uint32_t hostDisplayId) {
+ HWC2::Error error = HWC2::Error::None;
+
+ hwc2_display_t displayId = display->getId();
+ hwc2_config_t displayConfigId;
+ int32_t displayWidth;
+ int32_t displayHeight;
+
+ error = display->getActiveConfig(&displayConfigId);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " has no active config", __FUNCTION__,
+ displayId);
+ return error;
+ }
+
+ error = display->getDisplayAttributeEnum(
+ displayConfigId, HWC2::Attribute::Width, &displayWidth);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to get width", __FUNCTION__,
+ displayId);
+ return error;
+ }
+
+ error = display->getDisplayAttributeEnum(
+ displayConfigId, HWC2::Attribute::Height, &displayHeight);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to get height", __FUNCTION__,
+ displayId);
+ return error;
+ }
+
+ auto it = mDisplayInfos.find(displayId);
+ if (it != mDisplayInfos.end()) {
+ ALOGE("%s: display:%" PRIu64 " already created?", __FUNCTION__, displayId);
+ }
+
+ HostComposerDisplayInfo& displayInfo = mDisplayInfos[displayId];
+
+ displayInfo.hostDisplayId = hostDisplayId;
+
+ displayInfo.compositionResultBuffer =
+ AllocateDisplayColorBuffer(displayWidth, displayHeight);
+ if (displayInfo.compositionResultBuffer == nullptr) {
+ ALOGE("%s: display:%" PRIu64 " failed to create target buffer",
+ __FUNCTION__, displayId);
+ return HWC2::Error::NoResources;
+ }
+
+ if (mIsMinigbm) {
+ displayInfo.compositionResultDrmBuffer.reset(
+ new DrmBuffer(displayInfo.compositionResultBuffer, mDrmPresenter));
+
+ uint32_t vsyncPeriod = 1000 * 1000 * 1000 / mDrmPresenter.refreshRate();
+ error = display->setVsyncPeriod(vsyncPeriod);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to set vsync height", __FUNCTION__,
+ displayId);
+ return error;
+ }
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::onDisplayDestroy(Display* display) {
+ hwc2_display_t displayId = display->getId();
+
+ auto it = mDisplayInfos.find(displayId);
+ if (it == mDisplayInfos.end()) {
+ ALOGE("%s: display:%" PRIu64 " missing display buffers?", __FUNCTION__,
+ displayId);
+ return HWC2::Error::BadDisplay;
+ }
+
+ HostComposerDisplayInfo& displayInfo = mDisplayInfos[displayId];
+
+ if (displayId != 0) {
+ DEFINE_AND_VALIDATE_HOST_CONNECTION
+ hostCon->lock();
+ rcEnc->rcDestroyDisplay(rcEnc, displayInfo.hostDisplayId);
+ hostCon->unlock();
+ }
+
+ FreeDisplayColorBuffer(displayInfo.compositionResultBuffer);
+
+ mDisplayInfos.erase(it);
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::onDisplayClientTargetSet(Display* display) {
+ hwc2_display_t displayId = display->getId();
+
+ auto it = mDisplayInfos.find(displayId);
+ if (it == mDisplayInfos.end()) {
+ ALOGE("%s: display:%" PRIu64 " missing display buffers?", __FUNCTION__,
+ displayId);
+ return HWC2::Error::BadDisplay;
+ }
+
+ HostComposerDisplayInfo& displayInfo = mDisplayInfos[displayId];
+
+ if (mIsMinigbm) {
+ FencedBuffer& clientTargetFencedBuffer = display->getClientTarget();
+
+ displayInfo.clientTargetDrmBuffer.reset(
+ new DrmBuffer(clientTargetFencedBuffer.getBuffer(), mDrmPresenter));
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::validateDisplay(
+ Display* display, std::unordered_map<hwc2_layer_t, HWC2::Composition>*
+ layerCompositionChanges) {
+ DEFINE_AND_VALIDATE_HOST_CONNECTION
+ hostCon->lock();
+ bool hostCompositionV1 = rcEnc->hasHostCompositionV1();
+ bool hostCompositionV2 = rcEnc->hasHostCompositionV2();
+ hostCon->unlock();
+
+ const std::vector<Layer*> layers = display->getOrderedLayers();
+
+ if (hostCompositionV1 || hostCompositionV2) {
+ // Support Device and SolidColor, otherwise, fallback all layers to Client.
+ bool fallBack = false;
+ // TODO: use local var compositiontype, avoid call getCompositionType() many
+ // times
+ for (auto& layer : layers) {
+ if (layer->getCompositionType() == HWC2::Composition::Invalid) {
+ // Log error for unused layers, layer leak?
+ ALOGE("%s layer %u CompositionType(%d) not set", __FUNCTION__,
+ (uint32_t)layer->getId(), layer->getCompositionType());
+ continue;
+ }
+ if (layer->getCompositionType() == HWC2::Composition::Client ||
+ layer->getCompositionType() == HWC2::Composition::Cursor ||
+ layer->getCompositionType() == HWC2::Composition::Sideband) {
+ ALOGW("%s: layer %u CompositionType %d, fallback", __FUNCTION__,
+ (uint32_t)layer->getId(), layer->getCompositionType());
+ fallBack = true;
+ break;
+ }
+ }
+
+ if (display->hasColorTransform()) {
+ fallBack = true;
+ }
+
+ if (fallBack) {
+ for (auto& layer : layers) {
+ if (layer->getCompositionType() == HWC2::Composition::Invalid) {
+ continue;
+ }
+ if (layer->getCompositionType() != HWC2::Composition::Client) {
+ (*layerCompositionChanges)[layer->getId()] =
+ HWC2::Composition::Client;
+ }
+ }
+ }
+ } else {
+ for (auto& layer : layers) {
+ if (layer->getCompositionType() != HWC2::Composition::Client) {
+ (*layerCompositionChanges)[layer->getId()] = HWC2::Composition::Client;
+ }
+ }
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error HostComposer::presentDisplay(Display* display,
+ int32_t* outRetireFence) {
+ auto it = mDisplayInfos.find(display->getId());
+ if (it == mDisplayInfos.end()) {
+ ALOGE("%s: failed to find display buffers for display:%" PRIu64,
+ __FUNCTION__, display->getId());
+ return HWC2::Error::BadDisplay;
+ }
+
+ HostComposerDisplayInfo& displayInfo = it->second;
+
+ DEFINE_AND_VALIDATE_HOST_CONNECTION
+ hostCon->lock();
+ bool hostCompositionV1 = rcEnc->hasHostCompositionV1();
+ bool hostCompositionV2 = rcEnc->hasHostCompositionV2();
+ hostCon->unlock();
+
+ // Ff we supports v2, then discard v1
+ if (hostCompositionV2) {
+ hostCompositionV1 = false;
+ }
+
+ const std::vector<Layer*> layers = display->getOrderedLayers();
+ if (hostCompositionV2 || hostCompositionV1) {
+ uint32_t numLayer = 0;
+ for (auto layer : layers) {
+ if (layer->getCompositionType() == HWC2::Composition::Device ||
+ layer->getCompositionType() == HWC2::Composition::SolidColor) {
+ numLayer++;
+ }
+ }
+
+ DEBUG_LOG("%s: presenting display:%" PRIu64 " with %d layers", __FUNCTION__,
+ display->getId(), static_cast<int>(layers.size()));
+
+ display->clearReleaseFencesAndIdsLocked();
+
+ if (numLayer == 0) {
+ ALOGW(
+ "%s display has no layers to compose, flushing client target buffer.",
+ __FUNCTION__);
+
+ FencedBuffer& displayClientTarget = display->getClientTarget();
+ if (displayClientTarget.getBuffer() != nullptr) {
+ if (mIsMinigbm) {
+ int retireFence;
+ displayInfo.clientTargetDrmBuffer->flushToDisplay(display->getId(),
+ &retireFence);
+ *outRetireFence = dup(retireFence);
+ close(retireFence);
+ } else {
+ post(hostCon, rcEnc, displayClientTarget.getBuffer());
+ *outRetireFence = displayClientTarget.getFence();
+ }
+ }
+ return HWC2::Error::None;
+ }
+
+ std::unique_ptr<ComposeMsg> composeMsg;
+ std::unique_ptr<ComposeMsg_v2> composeMsgV2;
+
+ if (hostCompositionV1) {
+ composeMsg.reset(new ComposeMsg(numLayer));
+ } else {
+ composeMsgV2.reset(new ComposeMsg_v2(numLayer));
+ }
+
+ // Handle the composition
+ ComposeDevice* p;
+ ComposeDevice_v2* p2;
+ ComposeLayer* l;
+
+ if (hostCompositionV1) {
+ p = composeMsg->get();
+ l = p->layer;
+ } else {
+ p2 = composeMsgV2->get();
+ l = p2->layer;
+ }
+
+ int releaseLayersCount = 0;
+ for (auto layer : layers) {
+ // TODO: use local var composisitonType to store getCompositionType()
+ if (layer->getCompositionType() != HWC2::Composition::Device &&
+ layer->getCompositionType() != HWC2::Composition::SolidColor) {
+ ALOGE("%s: Unsupported composition types %d layer %u", __FUNCTION__,
+ layer->getCompositionType(), (uint32_t)layer->getId());
+ continue;
+ }
+ // send layer composition command to host
+ if (layer->getCompositionType() == HWC2::Composition::Device) {
+ display->addReleaseLayerLocked(layer->getId());
+ releaseLayersCount++;
+
+ int fence = layer->getBuffer().getFence();
+ if (fence != -1) {
+ int err = sync_wait(fence, 3000);
+ if (err < 0 && errno == ETIME) {
+ ALOGE("%s waited on fence %d for 3000 ms", __FUNCTION__, fence);
+ }
+ close(fence);
+ } else {
+ ALOGV("%s: acquire fence not set for layer %u", __FUNCTION__,
+ (uint32_t)layer->getId());
+ }
+ const native_handle_t* cb = layer->getBuffer().getBuffer();
+ if (cb != nullptr) {
+ l->cbHandle = hostCon->grallocHelper()->getHostHandle(cb);
+ } else {
+ ALOGE("%s null buffer for layer %d", __FUNCTION__,
+ (uint32_t)layer->getId());
+ }
+ } else {
+ // solidcolor has no buffer
+ l->cbHandle = 0;
+ }
+ l->composeMode = (hwc2_composition_t)layer->getCompositionType();
+ l->displayFrame = layer->getDisplayFrame();
+ l->crop = layer->getSourceCrop();
+ l->blendMode = static_cast<int32_t>(layer->getBlendMode());
+ l->alpha = layer->getPlaneAlpha();
+ l->color = layer->getColor();
+ l->transform = layer->getTransform();
+ ALOGV(
+ " cb %d blendmode %d alpha %f %d %d %d %d z %d"
+ " composeMode %d, transform %d",
+ l->cbHandle, l->blendMode, l->alpha, l->displayFrame.left,
+ l->displayFrame.top, l->displayFrame.right, l->displayFrame.bottom,
+ layer->getZ(), l->composeMode, l->transform);
+ l++;
+ }
+ if (hostCompositionV1) {
+ p->version = 1;
+ p->targetHandle = hostCon->grallocHelper()->getHostHandle(
+ displayInfo.compositionResultBuffer);
+ p->numLayers = numLayer;
+ } else {
+ p2->version = 2;
+ p2->displayId = displayInfo.hostDisplayId;
+ p2->targetHandle = hostCon->grallocHelper()->getHostHandle(
+ displayInfo.compositionResultBuffer);
+ p2->numLayers = numLayer;
+ }
+
+ hostCon->lock();
+ if (rcEnc->hasAsyncFrameCommands()) {
+ if (mIsMinigbm) {
+ if (hostCompositionV1) {
+ rcEnc->rcComposeAsyncWithoutPost(
+ rcEnc, sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
+ (void*)p);
+ } else {
+ rcEnc->rcComposeAsyncWithoutPost(
+ rcEnc, sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer),
+ (void*)p2);
+ }
+ } else {
+ if (hostCompositionV1) {
+ rcEnc->rcComposeAsync(
+ rcEnc, sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
+ (void*)p);
+ } else {
+ rcEnc->rcComposeAsync(
+ rcEnc, sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer),
+ (void*)p2);
+ }
+ }
+ } else {
+ if (mIsMinigbm) {
+ if (hostCompositionV1) {
+ rcEnc->rcComposeWithoutPost(
+ rcEnc, sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
+ (void*)p);
+ } else {
+ rcEnc->rcComposeWithoutPost(
+ rcEnc, sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer),
+ (void*)p2);
+ }
+ } else {
+ if (hostCompositionV1) {
+ rcEnc->rcCompose(
+ rcEnc, sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
+ (void*)p);
+ } else {
+ rcEnc->rcCompose(
+ rcEnc, sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer),
+ (void*)p2);
+ }
+ }
+ }
+
+ hostCon->unlock();
+
+ // Send a retire fence and use it as the release fence for all layers,
+ // since media expects it
+ EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_ANDROID,
+ EGL_NO_NATIVE_FENCE_FD_ANDROID};
+
+ uint64_t sync_handle, thread_handle;
+ int retire_fd;
+
+ hostCon->lock();
+ rcEnc->rcCreateSyncKHR(rcEnc, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs,
+ 2 * sizeof(EGLint), true /* destroy when signaled */,
+ &sync_handle, &thread_handle);
+ hostCon->unlock();
+
+ if (mIsMinigbm) {
+ displayInfo.compositionResultDrmBuffer->flushToDisplay(display->getId(),
+ &retire_fd);
+ } else {
+ goldfish_sync_queue_work(mSyncDeviceFd, sync_handle, thread_handle,
+ &retire_fd);
+ }
+
+ for (size_t i = 0; i < releaseLayersCount; ++i) {
+ display->addReleaseFenceLocked(dup(retire_fd));
+ }
+
+ *outRetireFence = dup(retire_fd);
+ close(retire_fd);
+ hostCon->lock();
+ if (rcEnc->hasAsyncFrameCommands()) {
+ rcEnc->rcDestroySyncKHRAsync(rcEnc, sync_handle);
+ } else {
+ rcEnc->rcDestroySyncKHR(rcEnc, sync_handle);
+ }
+ hostCon->unlock();
+
+ } else {
+ // we set all layers Composition::Client, so do nothing.
+ if (mIsMinigbm) {
+ int retireFence;
+ displayInfo.clientTargetDrmBuffer->flushToDisplay(display->getId(),
+ &retireFence);
+ *outRetireFence = dup(retireFence);
+ close(retireFence);
+ } else {
+ FencedBuffer& displayClientTarget = display->getClientTarget();
+ post(hostCon, rcEnc, displayClientTarget.getBuffer());
+ *outRetireFence = displayClientTarget.getFence();
+ }
+ ALOGV("%s fallback to post, returns outRetireFence %d", __FUNCTION__,
+ *outRetireFence);
+ }
+
+ return HWC2::Error::None;
+}
+
+void HostComposer::post(HostConnection* hostCon,
+ ExtendedRCEncoderContext* rcEnc, buffer_handle_t h) {
+ assert(cb && "native_handle_t::from(h) failed");
+
+ hostCon->lock();
+ rcEnc->rcFBPost(rcEnc, hostCon->grallocHelper()->getHostHandle(h));
+ hostCon->flush();
+ hostCon->unlock();
+}
+
+} // namespace android
diff --git a/system/hwc2/HostComposer.h b/system/hwc2/HostComposer.h
new file mode 100644
index 0000000..fe4a49f
--- /dev/null
+++ b/system/hwc2/HostComposer.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2021 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_HOSTCOMPOSER_H
+#define ANDROID_HWC_HOSTCOMPOSER_H
+
+#include "Common.h"
+#include "Composer.h"
+#include "DrmPresenter.h"
+#include "HostConnection.h"
+
+namespace android {
+
+class HostComposer : public Composer {
+ public:
+ HostComposer() = default;
+
+ HostComposer(const HostComposer&) = delete;
+ HostComposer& operator=(const HostComposer&) = delete;
+
+ HostComposer(HostComposer&&) = delete;
+ HostComposer& operator=(HostComposer&&) = delete;
+
+ HWC2::Error init(const HotplugCallback& cb) override;
+
+ HWC2::Error createDisplays(
+ Device* device,
+ const AddDisplayToDeviceFunction& addDisplayToDeviceFn) override;
+
+ HWC2::Error createDisplay(
+ Device* device, uint32_t displayId, uint32_t width, uint32_t height,
+ uint32_t dpiX, uint32_t dpiY, uint32_t refreshRateHz,
+ const AddDisplayToDeviceFunction& addDisplayToDeviceFn) override;
+
+ HWC2::Error onDisplayDestroy(Display* display) override;
+
+ HWC2::Error onDisplayClientTargetSet(Display* display) override;
+
+ // Determines if this composer can compose the given layers on the given
+ // display and requests changes for layers that can't not be composed.
+ HWC2::Error validateDisplay(
+ Display* display, std::unordered_map<hwc2_layer_t, HWC2::Composition>*
+ outLayerCompositionChanges) override;
+
+ // Performs the actual composition of layers and presents the composed result
+ // to the display.
+ HWC2::Error presentDisplay(Display* display,
+ int32_t* outPresentFence) override;
+
+ private:
+ HWC2::Error createPrimaryDisplay(
+ Device* device, const AddDisplayToDeviceFunction& addDisplayToDeviceFn);
+
+ HWC2::Error createSecondaryDisplays(
+ Device* device, const AddDisplayToDeviceFunction& addDisplayToDeviceFn);
+
+ HWC2::Error createHostComposerDisplayInfo(Display* display,
+ uint32_t hostDisplayId);
+
+ void post(HostConnection* hostCon, ExtendedRCEncoderContext* rcEnc,
+ buffer_handle_t h);
+
+ bool mIsMinigbm = false;
+
+ int mSyncDeviceFd = -1;
+
+ struct HostComposerDisplayInfo {
+ uint32_t hostDisplayId = 0;
+
+ // Additional per display buffer for the composition result.
+ const native_handle_t* compositionResultBuffer = nullptr;
+
+ // Drm info for the additional composition result buffer.
+ std::unique_ptr<DrmBuffer> compositionResultDrmBuffer;
+
+ // Drm info for the displays client target buffer.
+ std::unique_ptr<DrmBuffer> clientTargetDrmBuffer;
+ };
+
+ std::unordered_map<hwc2_display_t, HostComposerDisplayInfo> mDisplayInfos;
+
+ DrmPresenter mDrmPresenter;
+};
+
+} // namespace android
+
+#endif
diff --git a/system/hwc2/Layer.cpp b/system/hwc2/Layer.cpp
new file mode 100644
index 0000000..6cdfd33
--- /dev/null
+++ b/system/hwc2/Layer.cpp
@@ -0,0 +1,257 @@
+/*
+ * Copyright 2021 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 "Layer.h"
+
+#include <sync/sync.h>
+
+#include <atomic>
+
+namespace android {
+namespace {
+
+std::atomic<hwc2_layer_t> sNextId{1};
+
+} // namespace
+
+Layer::Layer() : mId(sNextId++) {}
+
+HWC2::Error Layer::setBuffer(buffer_handle_t buffer, int32_t fence) {
+ DEBUG_LOG("%s: layer:%" PRIu64 " buffer:%p fence:%" PRIu32, __FUNCTION__, mId,
+ buffer, fence);
+ mBuffer.setBuffer(buffer);
+ mBuffer.setFence(fence);
+ return HWC2::Error::None;
+}
+
+buffer_handle_t Layer::waitAndGetBuffer() {
+ DEBUG_LOG("%s layer:%" PRIu64, __FUNCTION__, mId);
+
+ int fence = mBuffer.getFence();
+ if (fence != -1) {
+ int err = sync_wait(fence, 3000);
+ if (err < 0 && errno == ETIME) {
+ ALOGE("%s waited on fence %" PRId32 " for 3000 ms", __FUNCTION__, fence);
+ }
+ close(fence);
+ }
+
+ return mBuffer.getBuffer();
+}
+
+HWC2::Error Layer::setCursorPosition(int32_t /*x*/, int32_t /*y*/) {
+ DEBUG_LOG("%s layer:%" PRIu64, __FUNCTION__, mId);
+
+ if (mCompositionType != HWC2::Composition::Cursor) {
+ ALOGE("%s: CompositionType not Cursor type", __FUNCTION__);
+ return HWC2::Error::BadLayer;
+ }
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Layer::setSurfaceDamage(hwc_region_t /*damage*/) {
+ DEBUG_LOG("%s layer:%" PRIu64, __FUNCTION__, mId);
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Layer::setBlendMode(int32_t m) {
+ const auto blendMode = static_cast<HWC2::BlendMode>(m);
+ const auto blendModeString = to_string(blendMode);
+ DEBUG_LOG("%s layer:%" PRIu64 " blend mode:%s", __FUNCTION__, mId,
+ blendModeString.c_str());
+
+ mBlendMode = blendMode;
+ return HWC2::Error::None;
+}
+
+HWC2::BlendMode Layer::getBlendMode() const {
+ const auto blendMode = mBlendMode;
+ const auto blendModeString = to_string(blendMode);
+ DEBUG_LOG("%s layer:%" PRIu64 " blend mode:%s", __FUNCTION__, mId,
+ blendModeString.c_str());
+
+ return blendMode;
+}
+
+HWC2::Error Layer::setColor(hwc_color_t color) {
+ DEBUG_LOG("%s layer:%" PRIu64 " color-r:%d color-g:%d color-b:%d color-a:%d)",
+ __FUNCTION__, mId, color.r, color.g, color.b, color.a);
+
+ mColor = color;
+ return HWC2::Error::None;
+}
+
+hwc_color_t Layer::getColor() const {
+ auto color = mColor;
+ DEBUG_LOG("%s layer:%" PRIu64 " color-r:%d color-g:%d color-b:%d color-a:%d)",
+ __FUNCTION__, mId, color.r, color.g, color.b, color.a);
+
+ return color;
+}
+
+HWC2::Error Layer::setCompositionTypeEnum(HWC2::Composition compositionType) {
+ const auto compositionTypeString = to_string(compositionType);
+ DEBUG_LOG("%s layer:%" PRIu64 " composition type:%s", __FUNCTION__, mId,
+ compositionTypeString.c_str());
+
+ mCompositionType = compositionType;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Layer::setCompositionType(int32_t type) {
+ const auto compositionType = static_cast<HWC2::Composition>(type);
+ return setCompositionTypeEnum(compositionType);
+}
+
+HWC2::Composition Layer::getCompositionType() const {
+ const auto compositionType = mCompositionType;
+ const auto compositionTypeString = to_string(compositionType);
+ DEBUG_LOG("%s layer:%" PRIu64 " composition type:%s", __FUNCTION__, mId,
+ compositionTypeString.c_str());
+
+ return compositionType;
+}
+
+HWC2::Error Layer::setDataspace(int32_t) {
+ DEBUG_LOG("%s layer:%" PRIu64, __FUNCTION__, mId);
+
+ return HWC2::Error::None;
+}
+
+HWC2::Error Layer::setDisplayFrame(hwc_rect_t frame) {
+ DEBUG_LOG("%s layer:%" PRIu64
+ " display frame rect-left:%d rect-top:%d rect-right:%d rect-bot:%d",
+ __FUNCTION__, mId, frame.left, frame.top, frame.right,
+ frame.bottom);
+
+ mDisplayFrame = frame;
+ return HWC2::Error::None;
+}
+
+hwc_rect_t Layer::getDisplayFrame() const {
+ auto frame = mDisplayFrame;
+ DEBUG_LOG("%s layer:%" PRIu64
+ " display frame rect-left:%d rect-top:%d rect-right:%d rect-bot:%d",
+ __FUNCTION__, mId, frame.left, frame.top, frame.right,
+ frame.bottom);
+
+ return frame;
+}
+
+HWC2::Error Layer::setPlaneAlpha(float alpha) {
+ DEBUG_LOG("%s layer:%" PRIu64 "alpha:%f", __FUNCTION__, mId, alpha);
+
+ mPlaneAlpha = alpha;
+ return HWC2::Error::None;
+}
+
+float Layer::getPlaneAlpha() const {
+ auto alpha = mPlaneAlpha;
+ DEBUG_LOG("%s layer:%" PRIu64 "alpha:%f", __FUNCTION__, mId, alpha);
+
+ return alpha;
+}
+
+HWC2::Error Layer::setSidebandStream(const native_handle_t* stream) {
+ DEBUG_LOG("%s layer:%" PRIu64, __FUNCTION__, mId);
+
+ mSidebandStream = stream;
+ return HWC2::Error::None;
+}
+
+HWC2::Error Layer::setSourceCrop(hwc_frect_t crop) {
+ DEBUG_LOG("%s layer:%" PRIu64
+ "crop rect-left:%f rect-top:%f rect-right:%f rect-bot:%f",
+ __FUNCTION__, mId, crop.left, crop.top, crop.right, crop.bottom);
+
+ mSourceCrop = crop;
+ return HWC2::Error::None;
+}
+
+hwc_frect_t Layer::getSourceCrop() const {
+ hwc_frect_t crop = mSourceCrop;
+ DEBUG_LOG("%s layer:%" PRIu64
+ "crop rect-left:%f rect-top:%f rect-right:%f rect-bot:%f",
+ __FUNCTION__, mId, crop.left, crop.top, crop.right, crop.bottom);
+
+ return crop;
+}
+
+hwc_rect_t Layer::getSourceCropInt() const {
+ hwc_rect_t crop = {};
+ crop.left = static_cast<int>(mSourceCrop.left);
+ crop.top = static_cast<int>(mSourceCrop.top);
+ crop.right = static_cast<int>(mSourceCrop.right);
+ crop.bottom = static_cast<int>(mSourceCrop.bottom);
+ DEBUG_LOG("%s layer:%" PRIu64
+ "crop rect-left:%d rect-top:%d rect-right:%d rect-bot:%d",
+ __FUNCTION__, mId, crop.left, crop.top, crop.right, crop.bottom);
+
+ return crop;
+}
+
+HWC2::Error Layer::setTransform(int32_t transform) {
+ const auto transformType = static_cast<HWC2::Transform>(transform);
+ const auto transformTypeString = to_string(transformType);
+ DEBUG_LOG("%s layer:%" PRIu64 " transform:%s", __FUNCTION__, mId,
+ transformTypeString.c_str());
+
+ mTransform = transformType;
+ return HWC2::Error::None;
+}
+
+hwc_transform_t Layer::getTransform() const {
+ const auto transform = mTransform;
+ const auto transformString = to_string(transform);
+ DEBUG_LOG("%s layer:%" PRIu64 " transform:%s", __FUNCTION__, mId,
+ transformString.c_str());
+
+ return static_cast<hwc_transform_t>(transform);
+}
+
+HWC2::Error Layer::setVisibleRegion(hwc_region_t visible) {
+ DEBUG_LOG("%s layer:%" PRIu64, __FUNCTION__, mId);
+
+ mVisibleRegion.resize(visible.numRects);
+ std::copy_n(visible.rects, visible.numRects, mVisibleRegion.data());
+ return HWC2::Error::None;
+}
+
+std::size_t Layer::getNumVisibleRegions() const {
+ std::size_t num = mVisibleRegion.size();
+ DEBUG_LOG("%s layer:%" PRIu64 " number of visible regions: %zu", __FUNCTION__,
+ mId, num);
+
+ return num;
+}
+
+HWC2::Error Layer::setZ(uint32_t z) {
+ DEBUG_LOG("%s layer:%" PRIu64 " z:%d", __FUNCTION__, mId, z);
+
+ mZ = z;
+ return HWC2::Error::None;
+}
+
+uint32_t Layer::getZ() const {
+ uint32_t z = mZ;
+ DEBUG_LOG("%s layer:%" PRIu64 " z:%d", __FUNCTION__, mId, z);
+
+ return z;
+}
+
+} // namespace android
\ No newline at end of file
diff --git a/system/hwc2/Layer.h b/system/hwc2/Layer.h
new file mode 100644
index 0000000..f576201
--- /dev/null
+++ b/system/hwc2/Layer.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2021 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_LAYER_H
+#define ANDROID_HWC_LAYER_H
+
+#include <vector>
+
+#include "Common.h"
+#include "FencedBuffer.h"
+
+namespace android {
+
+class Layer {
+ public:
+ explicit Layer();
+
+ Layer(const Layer&) = delete;
+ Layer& operator=(const Layer&) = delete;
+
+ Layer(Layer&&) = default;
+ Layer& operator=(Layer&&) = default;
+
+ HWC2::Error setBuffer(buffer_handle_t buffer, int32_t acquireFence);
+ FencedBuffer& getBuffer() { return mBuffer; }
+
+ buffer_handle_t waitAndGetBuffer();
+
+ hwc2_layer_t getId() const { return mId; }
+
+ HWC2::Error setCursorPosition(int32_t x, int32_t y);
+
+ HWC2::Error setSurfaceDamage(hwc_region_t damage);
+
+ HWC2::Error setBlendMode(int32_t mode);
+ HWC2::BlendMode getBlendMode() const;
+
+ HWC2::Error setColor(hwc_color_t color);
+ hwc_color_t getColor() const;
+
+ HWC2::Error setCompositionTypeEnum(HWC2::Composition type);
+ HWC2::Error setCompositionType(int32_t type);
+ HWC2::Composition getCompositionType() const;
+
+ HWC2::Error setDataspace(int32_t dataspace);
+
+ HWC2::Error setDisplayFrame(hwc_rect_t frame);
+ hwc_rect_t getDisplayFrame() const;
+
+ HWC2::Error setPlaneAlpha(float alpha);
+ float getPlaneAlpha() const;
+
+ HWC2::Error setSidebandStream(const native_handle_t* stream);
+
+ HWC2::Error setSourceCrop(hwc_frect_t crop);
+ hwc_frect_t getSourceCrop() const;
+ hwc_rect_t getSourceCropInt() const;
+
+ HWC2::Error setTransform(int32_t transform);
+ hwc_transform_t getTransform() const;
+
+ HWC2::Error setVisibleRegion(hwc_region_t visible);
+ std::size_t getNumVisibleRegions() const;
+
+ HWC2::Error setZ(uint32_t z);
+ uint32_t getZ() const;
+
+ private:
+ const hwc2_layer_t mId;
+ FencedBuffer mBuffer;
+ std::vector<hwc_rect_t> mSurfaceDamage;
+ HWC2::BlendMode mBlendMode = HWC2::BlendMode::None;
+ hwc_color_t mColor = {0, 0, 0, 0};
+ HWC2::Composition mCompositionType = HWC2::Composition::Invalid;
+ hwc_rect_t mDisplayFrame = {0, 0, -1, -1};
+ float mPlaneAlpha = 0.0f;
+ const native_handle_t* mSidebandStream = nullptr;
+ hwc_frect_t mSourceCrop = {0.0f, 0.0f, -1.0f, -1.0f};
+ HWC2::Transform mTransform = HWC2::Transform::None;
+ std::vector<hwc_rect_t> mVisibleRegion;
+ uint32_t mZ = 0;
+};
+
+} // namespace android
+
+#endif
\ No newline at end of file
diff --git a/system/hwc2/drmTest.cpp b/system/hwc2/drmTest.cpp
index 90d4341..86267da 100644
--- a/system/hwc2/drmTest.cpp
+++ b/system/hwc2/drmTest.cpp
@@ -7,114 +7,110 @@
#include <string.h>
#include <sys/mman.h>
#include <time.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/GraphicBufferAllocator.h>
#include <unistd.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
-#include <ui/GraphicBuffer.h>
-#include <ui/GraphicBufferAllocator.h>
+
#include "HostConnection.h"
#include "cros_gralloc_handle.h"
using namespace android;
struct buffer_object {
- uint32_t width;
- uint32_t height;
- uint32_t pitch;
- uint32_t handle;
- uint32_t size;
- uint8_t *vaddr;
- uint32_t fb_id;
- const native_handle_t* fb;
+ uint32_t width;
+ uint32_t height;
+ uint32_t pitch;
+ uint32_t handle;
+ uint32_t size;
+ uint8_t *vaddr;
+ uint32_t fb_id;
+ const native_handle_t *fb;
};
struct buffer_object buf;
-static int modeset_create_fb(int fd, struct buffer_object *bo)
-{
- struct drm_mode_create_dumb create = {};
- struct drm_mode_map_dumb map = {};
+static int modeset_create_fb(int fd, struct buffer_object *bo) {
+ struct drm_mode_create_dumb create = {};
+ struct drm_mode_map_dumb map = {};
- create.width = bo->width;
- create.height = bo->height;
- create.bpp = 32;
- drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &create);
- printf("create dumb w %d h %d\n", bo->width, bo->height);
- getchar();
+ create.width = bo->width;
+ create.height = bo->height;
+ create.bpp = 32;
+ drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &create);
+ printf("create dumb w %d h %d\n", bo->width, bo->height);
+ getchar();
- bo->pitch = create.pitch;
- bo->size = create.size;
- bo->handle = create.handle;
- drmModeAddFB(fd, bo->width, bo->height, 24, 32, bo->pitch,
- bo->handle, &bo->fb_id);
- printf("drmModeAddFB\n");
- getchar();
+ bo->pitch = create.pitch;
+ bo->size = create.size;
+ bo->handle = create.handle;
+ drmModeAddFB(fd, bo->width, bo->height, 24, 32, bo->pitch, bo->handle,
+ &bo->fb_id);
+ printf("drmModeAddFB\n");
+ getchar();
- map.handle = create.handle;
- drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &map);
- printf("map dumb\n");
- getchar();
- bo->vaddr = static_cast<unsigned char*>(mmap64(0, create.size, PROT_READ | PROT_WRITE,
- MAP_SHARED, fd, map.offset));
- memset(bo->vaddr, 0xff, bo->size);
- return 0;
+ map.handle = create.handle;
+ drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &map);
+ printf("map dumb\n");
+ getchar();
+ bo->vaddr = static_cast<unsigned char *>(mmap64(
+ 0, create.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, map.offset));
+ memset(bo->vaddr, 0xff, bo->size);
+ return 0;
}
-static void modeset_destroy_fb(int fd, struct buffer_object *bo)
-{
- struct drm_mode_destroy_dumb destroy = {};
+static void modeset_destroy_fb(int fd, struct buffer_object *bo) {
+ struct drm_mode_destroy_dumb destroy = {};
- drmModeRmFB(fd, bo->fb_id);
- munmap(bo->vaddr, bo->size);
- destroy.handle = bo->handle;
- drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy);
+ drmModeRmFB(fd, bo->fb_id);
+ munmap(bo->vaddr, bo->size);
+ destroy.handle = bo->handle;
+ drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy);
}
static uint32_t get_property_id(int fd, drmModeObjectProperties *props,
- const char *name)
-{
- drmModePropertyPtr property;
- uint32_t i, id = 0;
+ const char *name) {
+ drmModePropertyPtr property;
+ uint32_t i, id = 0;
- /* find property according to the name */
- for (i = 0; i < props->count_props; i++) {
- property = drmModeGetProperty(fd, props->props[i]);
- if (!strcmp(property->name, name))
- id = property->prop_id;
- drmModeFreeProperty(property);
- if (id) {
- break;
- }
+ /* find property according to the name */
+ for (i = 0; i < props->count_props; i++) {
+ property = drmModeGetProperty(fd, props->props[i]);
+ if (!strcmp(property->name, name)) id = property->prop_id;
+ drmModeFreeProperty(property);
+ if (id) {
+ break;
}
- return id;
+ }
+ return id;
}
static std::unique_ptr<HostConnection> sHostCon;
-static HostConnection* createOrGetHostConnection() {
- if (!sHostCon) {
- sHostCon = HostConnection::createUnique();
- }
- return sHostCon.get();
+static HostConnection *createOrGetHostConnection() {
+ if (!sHostCon) {
+ sHostCon = HostConnection::createUnique();
+ }
+ return sHostCon.get();
}
-#define DEFINE_AND_VALIDATE_HOST_CONNECTION \
- HostConnection *hostCon = createOrGetHostConnection(); \
- if (!hostCon) { \
- ALOGE("drmTest: Failed to get host connection\n"); \
- return; \
- } \
- ExtendedRCEncoderContext *rcEnc = hostCon->rcEncoder(); \
- if (!rcEnc) { \
- ALOGE("drmTest: Failed to get renderControl encoder context\n"); \
- return; \
- }
+#define DEFINE_AND_VALIDATE_HOST_CONNECTION \
+ HostConnection *hostCon = createOrGetHostConnection(); \
+ if (!hostCon) { \
+ ALOGE("drmTest: Failed to get host connection\n"); \
+ return; \
+ } \
+ ExtendedRCEncoderContext *rcEnc = hostCon->rcEncoder(); \
+ if (!rcEnc) { \
+ ALOGE("drmTest: Failed to get renderControl encoder context\n"); \
+ return; \
+ }
#include "include/drmhwcgralloc.h"
void convertBoInfo(buffer_handle_t handle, hwc_drm_bo_t *bo) {
cros_gralloc_handle *gr_handle = (cros_gralloc_handle *)handle;
- if (!gr_handle)
- return;
+ if (!gr_handle) return;
bo->width = gr_handle->width;
bo->height = gr_handle->height;
@@ -126,176 +122,169 @@
bo->offsets[0] = gr_handle->offsets[0];
}
-
void grallocAllocBuffer(int fd, struct buffer_object *bo) {
- buffer_handle_t h;
- uint32_t stride;
+ buffer_handle_t h;
+ uint32_t stride;
- if (GraphicBufferAllocator::get().allocate(
- bo->width, bo->height,
- android::PIXEL_FORMAT_RGBA_8888,
- 1,
- (GraphicBuffer::USAGE_HW_COMPOSER | GraphicBuffer::USAGE_HW_RENDER),
- &h, &stride,
- 0, "emulatorDrmTest") == android::OK) {
- hwc_drm_bo tmp_bo{};
- convertBoInfo(h, &tmp_bo);
+ if (GraphicBufferAllocator::get().allocate(
+ bo->width, bo->height, android::PIXEL_FORMAT_RGBA_8888, 1,
+ (GraphicBuffer::USAGE_HW_COMPOSER | GraphicBuffer::USAGE_HW_RENDER),
+ &h, &stride, 0, "emulatorDrmTest") == android::OK) {
+ hwc_drm_bo tmp_bo{};
+ convertBoInfo(h, &tmp_bo);
- int ret = drmPrimeFDToHandle(fd, tmp_bo.prime_fds[0], tmp_bo.gem_handles);
- for (int i = 1; i < HWC_DRM_BO_MAX_PLANES; i++) {
- tmp_bo.gem_handles[i] = tmp_bo.gem_handles[0];
- }
- if (ret) {
- printf("%s: DRM_IOCTL_PRIME_FD_TO_HANDLE failed: %s (errno %d)\n",
- __func__, strerror(errno), errno);
- return;
- }
- ret = drmModeAddFB2(fd, tmp_bo.width, tmp_bo.height, tmp_bo.format,
- tmp_bo.gem_handles, tmp_bo.pitches, tmp_bo.offsets, &bo->fb_id,
- 0);
-
- printf("allocate buffer\n");
- DEFINE_AND_VALIDATE_HOST_CONNECTION
- bo->fb = static_cast<const native_handle_t*>(h);
- getchar();
- printf("resource id is %d\n", hostCon->grallocHelper()->getHostHandle(bo->fb));
- } else {
- bo->fb = nullptr;
+ int ret = drmPrimeFDToHandle(fd, tmp_bo.prime_fds[0], tmp_bo.gem_handles);
+ for (int i = 1; i < HWC_DRM_BO_MAX_PLANES; i++) {
+ tmp_bo.gem_handles[i] = tmp_bo.gem_handles[0];
}
+ if (ret) {
+ printf("%s: DRM_IOCTL_PRIME_FD_TO_HANDLE failed: %s (errno %d)\n",
+ __func__, strerror(errno), errno);
+ return;
+ }
+ ret = drmModeAddFB2(fd, tmp_bo.width, tmp_bo.height, tmp_bo.format,
+ tmp_bo.gem_handles, tmp_bo.pitches, tmp_bo.offsets,
+ &bo->fb_id, 0);
+
+ printf("allocate buffer\n");
+ DEFINE_AND_VALIDATE_HOST_CONNECTION
+ bo->fb = static_cast<const native_handle_t *>(h);
+ getchar();
+ printf("resource id is %d\n",
+ hostCon->grallocHelper()->getHostHandle(bo->fb));
+ } else {
+ bo->fb = nullptr;
+ }
}
-int main(int argc, char **argv)
-{
- int fd;
- drmModeConnector *conn;
- drmModeRes *res;
- drmModePlaneRes *plane_res = nullptr;
- uint32_t conn_id;
- uint32_t crtc_id;
- uint32_t plane_id;
+int main(int argc, char **argv) {
+ int fd;
+ drmModeConnector *conn;
+ drmModeRes *res;
+ drmModePlaneRes *plane_res = nullptr;
+ uint32_t conn_id;
+ uint32_t crtc_id;
+ uint32_t plane_id;
- fd = open("/dev/dri/card0", O_RDWR | O_CLOEXEC);
+ fd = open("/dev/dri/card0", O_RDWR | O_CLOEXEC);
- int ret = drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 0);
- if (ret) {
- printf("fail to set universal plane %d\n", ret);
- }
+ int ret = drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 0);
+ if (ret) {
+ printf("fail to set universal plane %d\n", ret);
+ }
- res = drmModeGetResources(fd);
- crtc_id = res->crtcs[0];
- conn_id = res->connectors[0];
+ res = drmModeGetResources(fd);
+ crtc_id = res->crtcs[0];
+ conn_id = res->connectors[0];
- plane_res = drmModeGetPlaneResources(fd);
- plane_id = plane_res->planes[0];
+ plane_res = drmModeGetPlaneResources(fd);
+ plane_id = plane_res->planes[0];
- conn = drmModeGetConnector(fd, conn_id);
- buf.width = conn->modes[0].hdisplay;
- buf.height = conn->modes[0].vdisplay;
- //modeset_create_fb(fd, &buf);
- grallocAllocBuffer(fd, &buf);
+ conn = drmModeGetConnector(fd, conn_id);
+ buf.width = conn->modes[0].hdisplay;
+ buf.height = conn->modes[0].vdisplay;
+ // modeset_create_fb(fd, &buf);
+ grallocAllocBuffer(fd, &buf);
- drmModeSetCrtc(fd, crtc_id, buf.fb_id,
- 0, 0, &conn_id, 1, &conn->modes[0]);
- printf("drmModeSetCrtc\n");
- getchar();
+ drmModeSetCrtc(fd, crtc_id, buf.fb_id, 0, 0, &conn_id, 1, &conn->modes[0]);
+ printf("drmModeSetCrtc\n");
+ getchar();
- drmModePageFlip(fd, crtc_id, buf.fb_id, DRM_MODE_PAGE_FLIP_EVENT, &crtc_id);
- printf("drmModePageFlip\n");
- getchar();
+ drmModePageFlip(fd, crtc_id, buf.fb_id, DRM_MODE_PAGE_FLIP_EVENT, &crtc_id);
+ printf("drmModePageFlip\n");
+ getchar();
-// drmModeSetPlane(fd, plane_id, crtc_id, buf.fb_id, 0, 50, 50, 320, 320,
-// 100 << 16, 150 << 16, 320 << 16, 320 << 16);
-// printf("drmModeSetPlane\n");
-// modeset_destroy_fb(fd, &buf);
+ // drmModeSetPlane(fd, plane_id, crtc_id, buf.fb_id, 0, 50, 50, 320, 320,
+ // 100 << 16, 150 << 16, 320 << 16, 320 << 16);
+ // printf("drmModeSetPlane\n");
+ // modeset_destroy_fb(fd, &buf);
- drmModeFreeConnector(conn);
- drmModeFreeResources(res);
- close(fd);
+ drmModeFreeConnector(conn);
+ drmModeFreeResources(res);
+ close(fd);
- return 0;
+ return 0;
}
-int main_atom(int argc, char **argv)
-{
- int fd;
- drmModeConnector *conn = nullptr;
- drmModeRes *res = nullptr;
- drmModePlaneRes *plane_res = nullptr;
- drmModeObjectProperties *props = nullptr;
- drmModeAtomicReq *req;
- uint32_t conn_id;
- uint32_t crtc_id;
- uint32_t plane_id;
- uint32_t blob_id;
- uint32_t property_crtc_id;
- uint32_t property_mode_id;
- uint32_t property_active;
+int main_atom(int argc, char **argv) {
+ int fd;
+ drmModeConnector *conn = nullptr;
+ drmModeRes *res = nullptr;
+ drmModePlaneRes *plane_res = nullptr;
+ drmModeObjectProperties *props = nullptr;
+ drmModeAtomicReq *req;
+ uint32_t conn_id;
+ uint32_t crtc_id;
+ uint32_t plane_id;
+ uint32_t blob_id;
+ uint32_t property_crtc_id;
+ uint32_t property_mode_id;
+ uint32_t property_active;
- printf("drm available %d\n", drmAvailable());
- fd = open("/dev/dri/card0", O_RDWR);
- printf("openg drm fd %d\n", fd);
+ printf("drm available %d\n", drmAvailable());
+ fd = open("/dev/dri/card0", O_RDWR);
+ printf("openg drm fd %d\n", fd);
- int ret = drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
- if (ret) {
- printf("fail to set universal plane %d\n", ret);
- }
+ int ret = drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
+ if (ret) {
+ printf("fail to set universal plane %d\n", ret);
+ }
- ret = drmSetClientCap(fd, DRM_CLIENT_CAP_ATOMIC, 1);
- if (ret) {
- printf("fail to set atomic operation %d\n", ret);
- }
+ ret = drmSetClientCap(fd, DRM_CLIENT_CAP_ATOMIC, 1);
+ if (ret) {
+ printf("fail to set atomic operation %d\n", ret);
+ }
- res = drmModeGetResources(fd);
- if (!res) {
- printf("error to get drmModeGetResources: %d\n", errno);
- }
+ res = drmModeGetResources(fd);
+ if (!res) {
+ printf("error to get drmModeGetResources: %d\n", errno);
+ }
- crtc_id = res->crtcs[0];
- conn_id = res->connectors[0];
- plane_res = drmModeGetPlaneResources(fd);
- plane_id = plane_res->planes[0];
+ crtc_id = res->crtcs[0];
+ conn_id = res->connectors[0];
+ plane_res = drmModeGetPlaneResources(fd);
+ plane_id = plane_res->planes[0];
- conn = drmModeGetConnector(fd, conn_id);
- buf.width = conn->modes[0].hdisplay;
- buf.height = conn->modes[0].vdisplay;
- modeset_create_fb(fd, &buf);
+ conn = drmModeGetConnector(fd, conn_id);
+ buf.width = conn->modes[0].hdisplay;
+ buf.height = conn->modes[0].vdisplay;
+ modeset_create_fb(fd, &buf);
- /* get connector properties */
- props = drmModeObjectGetProperties(fd, conn_id, DRM_MODE_OBJECT_CONNECTOR);
- property_crtc_id = get_property_id(fd, props, "CRTC_ID");
- drmModeFreeObjectProperties(props);
+ /* get connector properties */
+ props = drmModeObjectGetProperties(fd, conn_id, DRM_MODE_OBJECT_CONNECTOR);
+ property_crtc_id = get_property_id(fd, props, "CRTC_ID");
+ drmModeFreeObjectProperties(props);
- /* get crtc properties */
- props = drmModeObjectGetProperties(fd, crtc_id, DRM_MODE_OBJECT_CRTC);
- property_active = get_property_id(fd, props, "ACTIVE");
- property_mode_id = get_property_id(fd, props, "MODE_ID");
- drmModeFreeObjectProperties(props);
+ /* get crtc properties */
+ props = drmModeObjectGetProperties(fd, crtc_id, DRM_MODE_OBJECT_CRTC);
+ property_active = get_property_id(fd, props, "ACTIVE");
+ property_mode_id = get_property_id(fd, props, "MODE_ID");
+ drmModeFreeObjectProperties(props);
- /* create blob to store current mode, and return the blob id */
- drmModeCreatePropertyBlob(fd, &conn->modes[0],
- sizeof(conn->modes[0]), &blob_id);
+ /* create blob to store current mode, and return the blob id */
+ drmModeCreatePropertyBlob(fd, &conn->modes[0], sizeof(conn->modes[0]),
+ &blob_id);
- /* start modeseting */
- req = drmModeAtomicAlloc();
- drmModeAtomicAddProperty(req, crtc_id, property_active, 1);
- drmModeAtomicAddProperty(req, crtc_id, property_mode_id, blob_id);
- drmModeAtomicAddProperty(req, conn_id, property_crtc_id, crtc_id);
- drmModeAtomicCommit(fd, req, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
- drmModeAtomicFree(req);
- printf("drmModeAtomicCommit SetCrtc\n");
- getchar();
+ /* start modeseting */
+ req = drmModeAtomicAlloc();
+ drmModeAtomicAddProperty(req, crtc_id, property_active, 1);
+ drmModeAtomicAddProperty(req, crtc_id, property_mode_id, blob_id);
+ drmModeAtomicAddProperty(req, conn_id, property_crtc_id, crtc_id);
+ drmModeAtomicCommit(fd, req, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+ drmModeAtomicFree(req);
+ printf("drmModeAtomicCommit SetCrtc\n");
+ getchar();
- drmModeSetPlane(fd, plane_id, crtc_id, buf.fb_id, 0,
- 50, 50, 320, 320,
- 0, 0, 320 << 16, 320 << 16);
- printf("drmModeSetPlane\n");
- getchar();
+ drmModeSetPlane(fd, plane_id, crtc_id, buf.fb_id, 0, 50, 50, 320, 320, 0, 0,
+ 320 << 16, 320 << 16);
+ printf("drmModeSetPlane\n");
+ getchar();
- modeset_destroy_fb(fd, &buf);
- drmModeFreeConnector(conn);
- drmModeFreePlaneResources(plane_res);
- drmModeFreeResources(res);
- close(fd);
+ modeset_destroy_fb(fd, &buf);
+ drmModeFreeConnector(conn);
+ drmModeFreePlaneResources(plane_res);
+ drmModeFreeResources(res);
+ close(fd);
- return 0;
+ return 0;
}
diff --git a/system/renderControl_enc/renderControl_client_context.cpp b/system/renderControl_enc/renderControl_client_context.cpp
index d9d5b61..2b3f0ae 100644
--- a/system/renderControl_enc/renderControl_client_context.cpp
+++ b/system/renderControl_enc/renderControl_client_context.cpp
@@ -72,6 +72,8 @@
rcDestroySyncKHRAsync = (rcDestroySyncKHRAsync_client_proc_t) getProc("rcDestroySyncKHRAsync", userData);
rcComposeWithoutPost = (rcComposeWithoutPost_client_proc_t) getProc("rcComposeWithoutPost", userData);
rcComposeAsyncWithoutPost = (rcComposeAsyncWithoutPost_client_proc_t) getProc("rcComposeAsyncWithoutPost", userData);
+ rcCreateDisplayById = (rcCreateDisplayById_client_proc_t) getProc("rcCreateDisplayById", userData);
+ rcSetDisplayPoseDpi = (rcSetDisplayPoseDpi_client_proc_t) getProc("rcSetDisplayPoseDpi", userData);
return 0;
}
diff --git a/system/renderControl_enc/renderControl_client_context.h b/system/renderControl_enc/renderControl_client_context.h
index 501de7f..cf2f8f0 100644
--- a/system/renderControl_enc/renderControl_client_context.h
+++ b/system/renderControl_enc/renderControl_client_context.h
@@ -72,6 +72,8 @@
rcDestroySyncKHRAsync_client_proc_t rcDestroySyncKHRAsync;
rcComposeWithoutPost_client_proc_t rcComposeWithoutPost;
rcComposeAsyncWithoutPost_client_proc_t rcComposeAsyncWithoutPost;
+ rcCreateDisplayById_client_proc_t rcCreateDisplayById;
+ rcSetDisplayPoseDpi_client_proc_t rcSetDisplayPoseDpi;
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 e31e843..2bd5d1f 100644
--- a/system/renderControl_enc/renderControl_client_proc.h
+++ b/system/renderControl_enc/renderControl_client_proc.h
@@ -74,6 +74,8 @@
typedef void (renderControl_APIENTRY *rcDestroySyncKHRAsync_client_proc_t) (void * ctx, uint64_t);
typedef GLint (renderControl_APIENTRY *rcComposeWithoutPost_client_proc_t) (void * ctx, uint32_t, void*);
typedef void (renderControl_APIENTRY *rcComposeAsyncWithoutPost_client_proc_t) (void * ctx, uint32_t, void*);
+typedef int (renderControl_APIENTRY *rcCreateDisplayById_client_proc_t) (void * ctx, uint32_t);
+typedef int (renderControl_APIENTRY *rcSetDisplayPoseDpi_client_proc_t) (void * ctx, uint32_t, GLint, GLint, uint32_t, uint32_t, uint32_t);
#endif
diff --git a/system/renderControl_enc/renderControl_enc.cpp b/system/renderControl_enc/renderControl_enc.cpp
index 5e6f751..1c544a8 100644
--- a/system/renderControl_enc/renderControl_enc.cpp
+++ b/system/renderControl_enc/renderControl_enc.cpp
@@ -2403,6 +2403,93 @@
stream->flush();
}
+int rcCreateDisplayById_enc(void *self , uint32_t displayId)
+{
+ AEMU_SCOPED_TRACE("rcCreateDisplayById 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;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_rcCreateDisplayById;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &displayId, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ 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("rcCreateDisplayById: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+int rcSetDisplayPoseDpi_enc(void *self , uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h, uint32_t dpi)
+{
+ AEMU_SCOPED_TRACE("rcSetDisplayPoseDpi 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;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 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_rcSetDisplayPoseDpi;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &displayId, 4); ptr += 4;
+ memcpy(ptr, &x, 4); ptr += 4;
+ memcpy(ptr, &y, 4); ptr += 4;
+ memcpy(ptr, &w, 4); ptr += 4;
+ memcpy(ptr, &h, 4); ptr += 4;
+ memcpy(ptr, &dpi, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ 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("rcSetDisplayPoseDpi: 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)
@@ -2472,5 +2559,7 @@
this->rcDestroySyncKHRAsync = &rcDestroySyncKHRAsync_enc;
this->rcComposeWithoutPost = &rcComposeWithoutPost_enc;
this->rcComposeAsyncWithoutPost = &rcComposeAsyncWithoutPost_enc;
+ this->rcCreateDisplayById = &rcCreateDisplayById_enc;
+ this->rcSetDisplayPoseDpi = &rcSetDisplayPoseDpi_enc;
}
diff --git a/system/renderControl_enc/renderControl_entry.cpp b/system/renderControl_enc/renderControl_entry.cpp
index 305625b..c58ddf5 100644
--- a/system/renderControl_enc/renderControl_entry.cpp
+++ b/system/renderControl_enc/renderControl_entry.cpp
@@ -67,6 +67,8 @@
void rcDestroySyncKHRAsync(uint64_t sync);
GLint rcComposeWithoutPost(uint32_t bufferSize, void* buffer);
void rcComposeAsyncWithoutPost(uint32_t bufferSize, void* buffer);
+ int rcCreateDisplayById(uint32_t displayId);
+ int rcSetDisplayPoseDpi(uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h, uint32_t dpi);
};
#ifndef GET_CONTEXT
@@ -447,3 +449,15 @@
ctx->rcComposeAsyncWithoutPost(ctx, bufferSize, buffer);
}
+int rcCreateDisplayById(uint32_t displayId)
+{
+ GET_CONTEXT;
+ return ctx->rcCreateDisplayById(ctx, displayId);
+}
+
+int rcSetDisplayPoseDpi(uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h, uint32_t dpi)
+{
+ GET_CONTEXT;
+ return ctx->rcSetDisplayPoseDpi(ctx, displayId, x, y, w, h, dpi);
+}
+
diff --git a/system/renderControl_enc/renderControl_ftable.h b/system/renderControl_enc/renderControl_ftable.h
index 2ee38b5..2adf3bf 100644
--- a/system/renderControl_enc/renderControl_ftable.h
+++ b/system/renderControl_enc/renderControl_ftable.h
@@ -70,6 +70,8 @@
{"rcDestroySyncKHRAsync", (void*)rcDestroySyncKHRAsync},
{"rcComposeWithoutPost", (void*)rcComposeWithoutPost},
{"rcComposeAsyncWithoutPost", (void*)rcComposeAsyncWithoutPost},
+ {"rcCreateDisplayById", (void*)rcCreateDisplayById},
+ {"rcSetDisplayPoseDpi", (void*)rcSetDisplayPoseDpi},
};
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 a3a6e27..732d3e0 100644
--- a/system/renderControl_enc/renderControl_opcodes.h
+++ b/system/renderControl_enc/renderControl_opcodes.h
@@ -65,7 +65,9 @@
#define OP_rcDestroySyncKHRAsync 10059
#define OP_rcComposeWithoutPost 10060
#define OP_rcComposeAsyncWithoutPost 10061
-#define OP_last 10062
+#define OP_rcCreateDisplayById 10062
+#define OP_rcSetDisplayPoseDpi 10063
+#define OP_last 10064
#endif
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
index 8fd790c..c4b3320 100644
--- a/system/vulkan/goldfish_vulkan.cpp
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -905,8 +905,7 @@
if (status != ZX_OK)
return std::nullopt;
- auto result = fuchsia_logger::LogSink::Call::Connect(
- channel, std::move(remote_socket));
+ auto result = WireCall(channel).Connect(std::move(remote_socket));
if (!result.ok())
return std::nullopt;
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index 407d9a4..6104c2d 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -178,6 +178,7 @@
using android::aligned_buf_free;
using android::base::Optional;
using android::base::guest::AutoLock;
+using android::base::guest::RecursiveLock;
using android::base::guest::Lock;
using android::base::guest::WorkPool;
@@ -338,7 +339,7 @@
};
struct VkQueue_Info {
- uint32_t placeholder;
+ VkDevice device;
};
// custom guest-side structs for images/buffers because of AHardwareBuffer :((
@@ -419,6 +420,10 @@
uint32_t unused;
};
+ struct VkSampler_Info {
+ uint32_t unused;
+ };
+
struct VkBufferCollectionFUCHSIA_Info {
#ifdef VK_USE_PLATFORM_FUCHSIA
android::base::Optional<
@@ -478,6 +483,13 @@
info_VkCommandPool.erase(pool);
}
+ void unregister_VkSampler(VkSampler sampler) {
+ if (!sampler) return;
+
+ AutoLock lock(mLock);
+ info_VkSampler.erase(sampler);
+ }
+
void unregister_VkCommandBuffer(VkCommandBuffer commandBuffer) {
resetCommandBufferStagingInfo(commandBuffer, true /* also reset primaries */, true /* also clear pending descriptor sets */);
@@ -709,34 +721,32 @@
return res;
}
- VkWriteDescriptorSet
- createImmutableSamplersFilteredWriteDescriptorSetLocked(
- const VkWriteDescriptorSet* descriptorWrite,
- std::vector<VkDescriptorImageInfo>* imageInfoArray) {
+ bool descriptorBindingIsImmutableSampler(
+ VkDescriptorSet dstSet,
+ uint32_t dstBinding) {
- VkWriteDescriptorSet res = *descriptorWrite;
+ return as_goldfish_VkDescriptorSet(dstSet)->reified->bindingIsImmutableSampler[dstBinding];
+ }
- if (descriptorWrite->descriptorCount == 0) return res;
+ VkDescriptorImageInfo
+ filterNonexistentSampler(
+ const VkDescriptorImageInfo& inputInfo) {
- if (descriptorWrite->descriptorType != VK_DESCRIPTOR_TYPE_SAMPLER &&
- descriptorWrite->descriptorType != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) return res;
+ VkSampler sampler =
+ inputInfo.sampler;
- bool immutableSampler =
- as_goldfish_VkDescriptorSet(descriptorWrite->dstSet)->reified->bindingIsImmutableSampler[descriptorWrite->dstBinding];
+ VkDescriptorImageInfo res = inputInfo;
- if (!immutableSampler) return res;
-
- for (uint32_t i = 0; i < descriptorWrite->descriptorCount; ++i) {
- VkDescriptorImageInfo imageInfo = descriptorWrite->pImageInfo[i];
- imageInfo.sampler = 0;
- imageInfoArray->push_back(imageInfo);
+ if (sampler) {
+ auto it = info_VkSampler.find(sampler);
+ bool samplerExists = it != info_VkSampler.end();
+ if (!samplerExists) res.sampler = 0;
}
- res.pImageInfo = imageInfoArray->data();
-
return res;
}
+
void freeDescriptorSetsIfHostAllocated(VkEncoder* enc, VkDevice device, uint32_t descriptorSetCount, const VkDescriptorSet* sets) {
for (uint32_t i = 0; i < descriptorSetCount; ++i) {
struct goldfish_VkDescriptorSet* ds = as_goldfish_VkDescriptorSet(sets[i]);
@@ -931,7 +941,7 @@
abort();
}
mControlDevice = std::make_unique<
- fuchsia_hardware_goldfish::ControlDevice::SyncClient>(
+ fidl::WireSyncClient<fuchsia_hardware_goldfish::ControlDevice>>(
std::move(channel));
fidl::ClientEnd<fuchsia_sysmem::Allocator> sysmem_channel{
@@ -940,7 +950,7 @@
ALOGE("failed to open sysmem connection");
}
mSysmemAllocator =
- std::make_unique<fuchsia_sysmem::Allocator::SyncClient>(
+ std::make_unique<fidl::WireSyncClient<fuchsia_sysmem::Allocator>>(
std::move(sysmem_channel));
char name[ZX_MAX_NAME_LEN] = {};
zx_object_get_property(zx_process_self(), ZX_PROP_NAME, name, sizeof(name));
@@ -949,7 +959,8 @@
zx_info_handle_basic_t info;
zx_object_get_info(zx_process_self(), ZX_INFO_HANDLE_BASIC, &info, sizeof(info),
nullptr, nullptr);
- mSysmemAllocator->SetDebugClientInfo(fidl::unowned_str(client_name), info.koid);
+ mSysmemAllocator->SetDebugClientInfo(fidl::StringView::FromExternal(client_name),
+ info.koid);
}
#endif
@@ -1145,6 +1156,7 @@
VkExternalMemoryHandleTypeFlags supportedHandleType = 0u;
#ifdef VK_USE_PLATFORM_FUCHSIA
supportedHandleType |=
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_ANDROID_KHR
@@ -1259,6 +1271,8 @@
VkExtensionProperties* pProperties) {
std::vector<const char*> allowedExtensionNames = {
+ "VK_KHR_vulkan_memory_model",
+ "VK_KHR_buffer_device_address",
"VK_KHR_maintenance1",
"VK_KHR_maintenance2",
"VK_KHR_maintenance3",
@@ -1271,6 +1285,9 @@
"VK_KHR_timeline_semaphore",
"VK_AMD_gpu_shader_half_float",
"VK_NV_shader_subgroup_partitioned",
+ "VK_KHR_shader_subgroup_extended_types",
+ "VK_EXT_subgroup_size_control",
+ "VK_KHR_pipeline_executable_properties",
#ifdef VK_USE_PLATFORM_ANDROID_KHR
"VK_KHR_external_semaphore",
"VK_KHR_external_semaphore_fd",
@@ -1576,6 +1593,23 @@
}
}
+ void on_vkGetDeviceQueue(void*,
+ VkDevice device,
+ uint32_t,
+ uint32_t,
+ VkQueue* pQueue) {
+ AutoLock lock(mLock);
+ info_VkQueue[*pQueue].device = device;
+ }
+
+ void on_vkGetDeviceQueue2(void*,
+ VkDevice device,
+ const VkDeviceQueueInfo2*,
+ VkQueue* pQueue) {
+ AutoLock lock(mLock);
+ info_VkQueue[*pQueue].device = device;
+ }
+
VkResult on_vkCreateInstance(
void* context,
VkResult input_result,
@@ -1740,10 +1774,11 @@
VkExternalMemoryHandleTypeFlagBits handleType,
uint32_t handle,
VkMemoryZirconHandlePropertiesFUCHSIA* pProperties) {
- using fuchsia_hardware_goldfish::wire::MEMORY_PROPERTY_DEVICE_LOCAL;
- using fuchsia_hardware_goldfish::wire::MEMORY_PROPERTY_HOST_VISIBLE;
+ using fuchsia_hardware_goldfish::wire::kMemoryPropertyDeviceLocal;
+ using fuchsia_hardware_goldfish::wire::kMemoryPropertyHostVisible;
- if (handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA) {
+ if (handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA &&
+ handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA) {
return VK_ERROR_INITIALIZATION_FAILED;
}
@@ -1788,7 +1823,7 @@
// 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.
- memoryProperty = MEMORY_PROPERTY_DEVICE_LOCAL;
+ memoryProperty = kMemoryPropertyDeviceLocal;
} else {
// Importing read-only host memory into the Vulkan driver should not
// work, but it is not an error to try to do so. Returning a
@@ -1802,10 +1837,10 @@
pProperties->memoryTypeBits = 0;
for (uint32_t i = 0; i < info.memProps.memoryTypeCount; ++i) {
- if (((memoryProperty & MEMORY_PROPERTY_DEVICE_LOCAL) &&
+ if (((memoryProperty & kMemoryPropertyDeviceLocal) &&
(info.memProps.memoryTypes[i].propertyFlags &
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) ||
- ((memoryProperty & MEMORY_PROPERTY_HOST_VISIBLE) &&
+ ((memoryProperty & kMemoryPropertyHostVisible) &&
(info.memProps.memoryTypes[i].propertyFlags &
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))) {
pProperties->memoryTypeBits |= 1ull << i;
@@ -1858,7 +1893,11 @@
if (info.eventHandle != ZX_HANDLE_INVALID) {
zx_handle_close(info.eventHandle);
}
+#if VK_HEADER_VERSION < 174
info.eventHandle = pInfo->handle;
+#else // VK_HEADER_VERSION >= 174
+ info.eventHandle = pInfo->zirconHandle;
+#endif // VK_HEADER_VERSION < 174
if (info.eventHandle != ZX_HANDLE_INVALID) {
info.eventKoid = getEventKoid(info.eventHandle);
}
@@ -1942,7 +1981,7 @@
}
auto* sysmem_collection =
- new fuchsia_sysmem::BufferCollection::SyncClient(
+ new fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>(
std::move(collection_client));
*pCollection = reinterpret_cast<VkBufferCollectionFUCHSIA>(sysmem_collection);
@@ -1955,7 +1994,7 @@
VkBufferCollectionFUCHSIA collection,
const VkAllocationCallbacks*) {
auto sysmem_collection = reinterpret_cast<
- fuchsia_sysmem::BufferCollection::SyncClient*>(collection);
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
if (sysmem_collection) {
sysmem_collection->Close();
}
@@ -1999,9 +2038,9 @@
buffer_constraints.inaccessible_domain_supported = true;
buffer_constraints.heap_permitted_count = 2;
buffer_constraints.heap_permitted[0] =
- fuchsia_sysmem::wire::HeapType::GOLDFISH_DEVICE_LOCAL;
+ fuchsia_sysmem::wire::HeapType::kGoldfishDeviceLocal;
buffer_constraints.heap_permitted[1] =
- fuchsia_sysmem::wire::HeapType::GOLDFISH_HOST_VISIBLE;
+ fuchsia_sysmem::wire::HeapType::kGoldfishHostVisible;
return constraints;
}
@@ -2011,15 +2050,15 @@
uint32_t usage = 0u;
VkImageUsageFlags imageUsage = pImageInfo->usage;
-#define SetUsageBit(USAGE) \
- if (imageUsage & VK_IMAGE_USAGE_##USAGE##_BIT) { \
- usage |= fuchsia_sysmem::wire::VULKAN_IMAGE_USAGE_##USAGE; \
+#define SetUsageBit(BIT, VALUE) \
+ if (imageUsage & VK_IMAGE_USAGE_##BIT##_BIT) { \
+ usage |= fuchsia_sysmem::wire::kVulkanImageUsage##VALUE; \
}
- SetUsageBit(COLOR_ATTACHMENT);
- SetUsageBit(TRANSFER_SRC);
- SetUsageBit(TRANSFER_DST);
- SetUsageBit(SAMPLED);
+ SetUsageBit(COLOR_ATTACHMENT, ColorAttachment);
+ SetUsageBit(TRANSFER_SRC, TransferSrc);
+ SetUsageBit(TRANSFER_DST, TransferDst);
+ SetUsageBit(SAMPLED, Sampled);
#undef SetUsageBit
return usage;
@@ -2031,20 +2070,20 @@
VkBufferUsageFlags bufferUsage =
pBufferConstraintsInfo->pBufferCreateInfo->usage;
-#define SetUsageBit(USAGE) \
- if (bufferUsage & VK_BUFFER_USAGE_##USAGE##_BIT) { \
- usage |= fuchsia_sysmem::wire::VULKAN_BUFFER_USAGE_##USAGE; \
+#define SetUsageBit(BIT, VALUE) \
+ if (bufferUsage & VK_BUFFER_USAGE_##BIT##_BIT) { \
+ usage |= fuchsia_sysmem::wire::kVulkanBufferUsage##VALUE; \
}
- SetUsageBit(TRANSFER_SRC);
- SetUsageBit(TRANSFER_DST);
- SetUsageBit(UNIFORM_TEXEL_BUFFER);
- SetUsageBit(STORAGE_TEXEL_BUFFER);
- SetUsageBit(UNIFORM_BUFFER);
- SetUsageBit(STORAGE_BUFFER);
- SetUsageBit(INDEX_BUFFER);
- SetUsageBit(VERTEX_BUFFER);
- SetUsageBit(INDIRECT_BUFFER);
+ SetUsageBit(TRANSFER_SRC, TransferSrc);
+ SetUsageBit(TRANSFER_DST, TransferDst);
+ SetUsageBit(UNIFORM_TEXEL_BUFFER, UniformTexelBuffer);
+ SetUsageBit(STORAGE_TEXEL_BUFFER, StorageTexelBuffer);
+ SetUsageBit(UNIFORM_BUFFER, UniformBuffer);
+ SetUsageBit(STORAGE_BUFFER, StorageBuffer);
+ SetUsageBit(INDEX_BUFFER, IndexBuffer);
+ SetUsageBit(VERTEX_BUFFER, VertexBuffer);
+ SetUsageBit(INDIRECT_BUFFER, IndirectBuffer);
#undef SetUsageBit
return usage;
@@ -2059,14 +2098,14 @@
case VK_FORMAT_B8G8R8A8_SNORM:
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_B8G8R8A8_USCALED:
- return fuchsia_sysmem::wire::PixelFormatType::BGRA32;
+ return fuchsia_sysmem::wire::PixelFormatType::kBgra32;
case VK_FORMAT_R8G8B8A8_SINT:
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_R8G8B8A8_SNORM:
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_R8G8B8A8_USCALED:
- return fuchsia_sysmem::wire::PixelFormatType::R8G8B8A8;
+ return fuchsia_sysmem::wire::PixelFormatType::kR8G8B8A8;
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8_UINT:
case VK_FORMAT_R8_USCALED:
@@ -2074,7 +2113,7 @@
case VK_FORMAT_R8_SINT:
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8_SRGB:
- return fuchsia_sysmem::wire::PixelFormatType::R8;
+ return fuchsia_sysmem::wire::PixelFormatType::kR8;
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8_UINT:
case VK_FORMAT_R8G8_USCALED:
@@ -2082,9 +2121,9 @@
case VK_FORMAT_R8G8_SINT:
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8_SRGB:
- return fuchsia_sysmem::wire::PixelFormatType::R8G8;
+ return fuchsia_sysmem::wire::PixelFormatType::kR8G8;
default:
- return fuchsia_sysmem::wire::PixelFormatType::INVALID;
+ return fuchsia_sysmem::wire::PixelFormatType::kInvalid;
}
}
@@ -2099,7 +2138,7 @@
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_B8G8R8A8_USCALED:
return sysmemFormat ==
- fuchsia_sysmem::wire::PixelFormatType::BGRA32;
+ fuchsia_sysmem::wire::PixelFormatType::kBgra32;
case VK_FORMAT_R8G8B8A8_SINT:
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_R8G8B8A8_SRGB:
@@ -2107,7 +2146,7 @@
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_R8G8B8A8_USCALED:
return sysmemFormat ==
- fuchsia_sysmem::wire::PixelFormatType::R8G8B8A8;
+ fuchsia_sysmem::wire::PixelFormatType::kR8G8B8A8;
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8_UINT:
case VK_FORMAT_R8_USCALED:
@@ -2116,9 +2155,9 @@
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8_SRGB:
return sysmemFormat ==
- fuchsia_sysmem::wire::PixelFormatType::R8 ||
+ fuchsia_sysmem::wire::PixelFormatType::kR8 ||
sysmemFormat ==
- fuchsia_sysmem::wire::PixelFormatType::L8;
+ fuchsia_sysmem::wire::PixelFormatType::kL8;
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8_UINT:
case VK_FORMAT_R8G8_USCALED:
@@ -2127,7 +2166,7 @@
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8_SRGB:
return sysmemFormat ==
- fuchsia_sysmem::wire::PixelFormatType::R8G8;
+ fuchsia_sysmem::wire::PixelFormatType::kR8G8;
default:
return false;
}
@@ -2136,14 +2175,14 @@
static VkFormat sysmemPixelFormatTypeToVk(
fuchsia_sysmem::wire::PixelFormatType format) {
switch (format) {
- case fuchsia_sysmem::wire::PixelFormatType::BGRA32:
+ case fuchsia_sysmem::wire::PixelFormatType::kBgra32:
return VK_FORMAT_B8G8R8A8_SRGB;
- case fuchsia_sysmem::wire::PixelFormatType::R8G8B8A8:
+ case fuchsia_sysmem::wire::PixelFormatType::kR8G8B8A8:
return VK_FORMAT_R8G8B8A8_SRGB;
- case fuchsia_sysmem::wire::PixelFormatType::L8:
- case fuchsia_sysmem::wire::PixelFormatType::R8:
+ case fuchsia_sysmem::wire::PixelFormatType::kL8:
+ case fuchsia_sysmem::wire::PixelFormatType::kR8:
return VK_FORMAT_R8_UNORM;
- case fuchsia_sysmem::wire::PixelFormatType::R8G8:
+ case fuchsia_sysmem::wire::PixelFormatType::kR8G8:
return VK_FORMAT_R8G8_UNORM;
default:
return VK_FORMAT_UNDEFINED;
@@ -2152,7 +2191,7 @@
VkResult setBufferCollectionConstraints(
VkEncoder* enc, VkDevice device,
- fuchsia_sysmem::BufferCollection::SyncClient* collection,
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* collection,
const VkImageCreateInfo* pImageInfo) {
if (pImageInfo == nullptr) {
ALOGE("setBufferCollectionConstraints: pImageInfo cannot be null.");
@@ -2262,7 +2301,7 @@
} else {
auto pixel_format = vkFormatTypeToSysmem(createInfo->format);
if (pixel_format ==
- fuchsia_sysmem::wire::PixelFormatType::INVALID) {
+ fuchsia_sysmem::wire::PixelFormatType::kInvalid) {
ALOGW("%s: Unsupported VkFormat %u", __func__,
static_cast<uint32_t>(createInfo->format));
return VK_ERROR_FORMAT_NOT_SUPPORTED;
@@ -2273,7 +2312,7 @@
if (!formatConstraints || formatConstraints->colorSpaceCount == 0u) {
imageConstraints.color_spaces_count = 1;
imageConstraints.color_space[0].type =
- fuchsia_sysmem::wire::ColorSpaceType::SRGB;
+ fuchsia_sysmem::wire::ColorSpaceType::kSrgb;
} else {
imageConstraints.color_spaces_count =
formatConstraints->colorSpaceCount;
@@ -2315,9 +2354,8 @@
imageConstraints.pixel_format.has_format_modifier = true;
imageConstraints.pixel_format.format_modifier.value =
(tiling == VK_IMAGE_TILING_LINEAR)
- ? fuchsia_sysmem::wire::FORMAT_MODIFIER_LINEAR
- : fuchsia_sysmem::wire::
- FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL;
+ ? fuchsia_sysmem::wire::kFormatModifierLinear
+ : fuchsia_sysmem::wire::kFormatModifierGoogleGoldfishOptimal;
constraints->image_format_constraints
[constraints->image_format_constraints_count++] =
@@ -2328,7 +2366,7 @@
VkResult setBufferCollectionImageConstraints(
VkEncoder* enc,
VkDevice device,
- fuchsia_sysmem::BufferCollection::SyncClient* collection,
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* collection,
const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
if (!pImageConstraintsInfo ||
pImageConstraintsInfo->sType !=
@@ -2413,13 +2451,13 @@
// and flags.
VkImageConstraintsInfoFlagsFUCHSIA flags = pImageConstraintsInfo->flags;
if (flags & VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA)
- constraints.usage.cpu |= fuchsia_sysmem::wire::cpuUsageRead;
+ constraints.usage.cpu |= fuchsia_sysmem::wire::kCpuUsageRead;
if (flags & VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA)
- constraints.usage.cpu |= fuchsia_sysmem::wire::cpuUsageReadOften;
+ constraints.usage.cpu |= fuchsia_sysmem::wire::kCpuUsageReadOften;
if (flags & VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA)
- constraints.usage.cpu |= fuchsia_sysmem::wire::cpuUsageWrite;
+ constraints.usage.cpu |= fuchsia_sysmem::wire::kCpuUsageWrite;
if (flags & VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA)
- constraints.usage.cpu |= fuchsia_sysmem::wire::cpuUsageWriteOften;
+ constraints.usage.cpu |= fuchsia_sysmem::wire::kCpuUsageWriteOften;
constraints.has_buffer_memory_constraints = true;
auto& memory_constraints = constraints.buffer_memory_constraints;
@@ -2435,13 +2473,13 @@
if (memory_constraints.inaccessible_domain_supported) {
memory_constraints.heap_permitted_count = 2;
memory_constraints.heap_permitted[0] =
- fuchsia_sysmem::wire::HeapType::GOLDFISH_DEVICE_LOCAL;
+ fuchsia_sysmem::wire::HeapType::kGoldfishDeviceLocal;
memory_constraints.heap_permitted[1] =
- fuchsia_sysmem::wire::HeapType::GOLDFISH_HOST_VISIBLE;
+ fuchsia_sysmem::wire::HeapType::kGoldfishHostVisible;
} else {
memory_constraints.heap_permitted_count = 1;
memory_constraints.heap_permitted[0] =
- fuchsia_sysmem::wire::HeapType::GOLDFISH_HOST_VISIBLE;
+ fuchsia_sysmem::wire::HeapType::kGoldfishHostVisible;
}
if (constraints.image_format_constraints_count == 0) {
@@ -2451,9 +2489,8 @@
}
constexpr uint32_t kVulkanPriority = 5;
- const char* kName = "GoldfishSysmemShared";
- collection->SetName(kVulkanPriority,
- fidl::unowned_str(kName, strlen(kName)));
+ const char kName[] = "GoldfishSysmemShared";
+ collection->SetName(kVulkanPriority, fidl::StringView(kName));
auto result = collection->SetConstraints(true, constraints);
if (!result.ok()) {
@@ -2479,7 +2516,7 @@
}
VkResult setBufferCollectionBufferConstraints(
- fuchsia_sysmem::BufferCollection::SyncClient* collection,
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* collection,
const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
if (pBufferConstraintsInfo == nullptr) {
ALOGE(
@@ -2497,8 +2534,8 @@
pBufferConstraintsInfo);
constexpr uint32_t kVulkanPriority = 5;
- const char* kName = "GoldfishBufferSysmemShared";
- collection->SetName(kVulkanPriority, fidl::unowned_str(kName, strlen(kName)));
+ const char kName[] = "GoldfishBufferSysmemShared";
+ collection->SetName(kVulkanPriority, fidl::StringView(kName));
auto result = collection->SetConstraints(true, constraints);
if (!result.ok()) {
@@ -2527,7 +2564,7 @@
const VkImageCreateInfo* pImageInfo) {
VkEncoder* enc = (VkEncoder*)context;
auto sysmem_collection = reinterpret_cast<
- fuchsia_sysmem::BufferCollection::SyncClient*>(collection);
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
return setBufferCollectionConstraints(enc, device, sysmem_collection, pImageInfo);
}
@@ -2539,7 +2576,7 @@
const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
VkEncoder* enc = (VkEncoder*)context;
auto sysmem_collection = reinterpret_cast<
- fuchsia_sysmem::BufferCollection::SyncClient*>(collection);
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
return setBufferCollectionImageConstraints(
enc, device, sysmem_collection, pImageConstraintsInfo);
}
@@ -2551,7 +2588,7 @@
VkBufferCollectionFUCHSIA collection,
const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
auto sysmem_collection = reinterpret_cast<
- fuchsia_sysmem::BufferCollection::SyncClient*>(collection);
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
return setBufferCollectionBufferConstraints(sysmem_collection,
pBufferConstraintsInfo);
}
@@ -2578,7 +2615,7 @@
VkResult getBufferCollectionImageCreateInfoIndexLocked(
VkBufferCollectionFUCHSIA collection,
- fuchsia_sysmem::wire::BufferCollectionInfo_2& info,
+ fuchsia_sysmem::wire::BufferCollectionInfo2& info,
uint32_t* outCreateInfoIndex) {
if (!info_VkBufferCollectionFUCHSIA[collection]
.constraints.hasValue()) {
@@ -2655,7 +2692,7 @@
VkBufferCollectionProperties2FUCHSIA* pProperties) {
VkEncoder* enc = (VkEncoder*)context;
auto sysmem_collection = reinterpret_cast<
- fuchsia_sysmem::BufferCollection::SyncClient*>(collection);
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
auto result = sysmem_collection->WaitForBuffersAllocated();
if (!result.ok() || result.Unwrap()->status != ZX_OK) {
@@ -2663,13 +2700,13 @@
GET_STATUS_SAFE(result, status));
return VK_ERROR_INITIALIZATION_FAILED;
}
- fuchsia_sysmem::wire::BufferCollectionInfo_2 info =
+ 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::GOLDFISH_HOST_VISIBLE;
+ fuchsia_sysmem::wire::HeapType::kGoldfishHostVisible;
bool is_device_local = info.settings.buffer_settings.heap ==
- fuchsia_sysmem::wire::HeapType::GOLDFISH_DEVICE_LOCAL;
+ 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));
@@ -3024,6 +3061,11 @@
const VkImportMemoryZirconHandleInfoFUCHSIA* importVmoInfoPtr =
vk_find_struct<VkImportMemoryZirconHandleInfoFUCHSIA>(pAllocateInfo);
+ if (!importVmoInfoPtr) {
+ importVmoInfoPtr = reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(
+ __vk_find_struct(const_cast<void*>(pAllocateInfo->pNext),
+ VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA));
+ }
const VkMemoryDedicatedAllocateInfo* dedicatedAllocInfoPtr =
vk_find_struct<VkMemoryDedicatedAllocateInfo>(pAllocateInfo);
@@ -3080,8 +3122,10 @@
exportAllocateInfoPtr->handleTypes &
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
exportVmo =
- exportAllocateInfoPtr->handleTypes &
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
+ (exportAllocateInfoPtr->handleTypes &
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA) ||
+ (exportAllocateInfoPtr->handleTypes &
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA);
} else if (importAhbInfoPtr) {
importAhb = true;
} else if (importBufferCollectionInfoPtr) {
@@ -3172,7 +3216,7 @@
#ifdef VK_USE_PLATFORM_FUCHSIA
auto collection = reinterpret_cast<
- fuchsia_sysmem::BufferCollection::SyncClient*>(
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(
importBufferCollectionInfoPtr->collection);
auto result = collection->WaitForBuffersAllocated();
if (!result.ok() || result.Unwrap()->status != ZX_OK) {
@@ -3180,7 +3224,7 @@
GET_STATUS_SAFE(result, status));
return VK_ERROR_INITIALIZATION_FAILED;
}
- fuchsia_sysmem::wire::BufferCollectionInfo_2& info =
+ fuchsia_sysmem::wire::BufferCollectionInfo2& info =
result.Unwrap()->buffer_collection_info;
uint32_t index = importBufferCollectionInfoPtr->index;
if (info.buffer_count < index) {
@@ -3290,7 +3334,7 @@
}
}
- fuchsia_sysmem::BufferCollection::SyncClient collection(
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection> collection(
std::move(collection_ends->client));
if (hasDedicatedImage) {
VkResult res = setBufferCollectionConstraints(
@@ -3319,7 +3363,7 @@
{
auto result = collection.WaitForBuffersAllocated();
if (result.ok() && result.Unwrap()->status == ZX_OK) {
- fuchsia_sysmem::wire::BufferCollectionInfo_2& info =
+ fuchsia_sysmem::wire::BufferCollectionInfo2& info =
result.Unwrap()->buffer_collection_info;
if (!info.buffer_count) {
ALOGE(
@@ -3365,7 +3409,7 @@
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_B8G8R8A8_USCALED:
format = fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType::BGRA;
+ ColorBufferFormatType::kBgra;
break;
case VK_FORMAT_R8G8B8A8_SINT:
case VK_FORMAT_R8G8B8A8_UNORM:
@@ -3374,7 +3418,7 @@
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_R8G8B8A8_USCALED:
format = fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType::RGBA;
+ ColorBufferFormatType::kRgba;
break;
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8_UINT:
@@ -3384,7 +3428,7 @@
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8_SRGB:
format = fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType::LUMINANCE;
+ ColorBufferFormatType::kLuminance;
break;
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8_UINT:
@@ -3394,7 +3438,7 @@
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8_SRGB:
format = fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType::RG;
+ ColorBufferFormatType::kRg;
break;
default:
ALOGE("Unsupported format: %d",
@@ -3402,25 +3446,14 @@
abort();
}
- auto createParams =
- fuchsia_hardware_goldfish::wire::
- CreateColorBuffer2Params::Builder(
- std::make_unique<
- fuchsia_hardware_goldfish::wire::
- CreateColorBuffer2Params::Frame>())
- .set_width(std::make_unique<uint32_t>(
- pImageCreateInfo->extent.width))
- .set_height(std::make_unique<uint32_t>(
- pImageCreateInfo->extent.height))
- .set_format(
- std::make_unique<
- fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType>(format))
- .set_memory_property(
- std::make_unique<uint32_t>(
- fuchsia_hardware_goldfish::wire::
- MEMORY_PROPERTY_DEVICE_LOCAL))
- .build();
+ fidl::FidlAllocator allocator;
+ fuchsia_hardware_goldfish::wire::CreateColorBuffer2Params createParams(
+ allocator);
+ createParams.set_width(allocator, pImageCreateInfo->extent.width)
+ .set_height(allocator, pImageCreateInfo->extent.height)
+ .set_format(allocator, format)
+ .set_memory_property(allocator,
+ fuchsia_hardware_goldfish::wire::kMemoryPropertyDeviceLocal);
auto result = mControlDevice->CreateColorBuffer2(
std::move(vmo_copy), std::move(createParams));
@@ -3441,15 +3474,12 @@
}
if (pBufferConstraintsInfo) {
- auto createParams =
- fuchsia_hardware_goldfish::wire::CreateBuffer2Params::Builder(
- std::make_unique<
- fuchsia_hardware_goldfish::wire::CreateBuffer2Params::Frame>())
- .set_size(std::make_unique<uint64_t>(
- pBufferConstraintsInfo->pBufferCreateInfo->size))
- .set_memory_property(std::make_unique<uint32_t>(
- fuchsia_hardware_goldfish::wire::MEMORY_PROPERTY_DEVICE_LOCAL))
- .build();
+ fidl::FidlAllocator allocator;
+ fuchsia_hardware_goldfish::wire::CreateBuffer2Params createParams(allocator);
+ createParams.set_size(allocator,
+ pBufferConstraintsInfo->pBufferCreateInfo->size)
+ .set_memory_property(allocator,
+ fuchsia_hardware_goldfish::wire::kMemoryPropertyDeviceLocal);
auto result =
mControlDevice->CreateBuffer2(std::move(vmo_copy), std::move(createParams));
@@ -3483,7 +3513,7 @@
uint32_t buffer_handle = result.Unwrap()->id;
if (handle_type == fuchsia_hardware_goldfish::wire::
- BufferHandleType::BUFFER) {
+ BufferHandleType::kBuffer) {
importBufferInfo.buffer = buffer_handle;
vk_append_struct(&structChainIter, &importBufferInfo);
} else {
@@ -3913,19 +3943,21 @@
bool isSysmemBackedMemory = false;
if (extImgCiPtr &&
+ ((extImgCiPtr->handleTypes &
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA) ||
(extImgCiPtr->handleTypes &
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)) {
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA))) {
isSysmemBackedMemory = true;
}
if (extBufferCollectionPtr) {
auto collection = reinterpret_cast<
- fuchsia_sysmem::BufferCollection::SyncClient*>(
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(
extBufferCollectionPtr->collection);
uint32_t index = extBufferCollectionPtr->index;
zx::vmo vmo;
- fuchsia_sysmem::wire::BufferCollectionInfo_2 info;
+ fuchsia_sysmem::wire::BufferCollectionInfo2 info;
auto result = collection->WaitForBuffersAllocated();
if (result.ok() && result.Unwrap()->status == ZX_OK) {
@@ -3956,7 +3988,7 @@
// Buffer handle already exists.
// If it is a ColorBuffer, no-op; Otherwise return error.
if (buffer_handle_result.value().type !=
- fuchsia_hardware_goldfish::wire::BufferHandleType::COLOR_BUFFER) {
+ fuchsia_hardware_goldfish::wire::BufferHandleType::kColorBuffer) {
ALOGE("%s: BufferHandle %u is not a ColorBuffer", __func__,
buffer_handle_result.value().id);
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -3965,29 +3997,25 @@
// Buffer handle not found. Create ColorBuffer based on buffer settings.
auto format =
info.settings.image_format_constraints.pixel_format.type ==
- fuchsia_sysmem::wire::PixelFormatType::R8G8B8A8
- ? fuchsia_hardware_goldfish::wire::ColorBufferFormatType::RGBA
- : fuchsia_hardware_goldfish::wire::ColorBufferFormatType::BGRA;
+ fuchsia_sysmem::wire::PixelFormatType::kR8G8B8A8
+ ? fuchsia_hardware_goldfish::wire::ColorBufferFormatType::kRgba
+ : fuchsia_hardware_goldfish::wire::ColorBufferFormatType::kBgra;
uint32_t memory_property =
info.settings.buffer_settings.heap ==
- fuchsia_sysmem::wire::HeapType::GOLDFISH_DEVICE_LOCAL
- ? fuchsia_hardware_goldfish::wire::MEMORY_PROPERTY_DEVICE_LOCAL
- : fuchsia_hardware_goldfish::wire::MEMORY_PROPERTY_HOST_VISIBLE;
+ fuchsia_sysmem::wire::HeapType::kGoldfishDeviceLocal
+ ? fuchsia_hardware_goldfish::wire::kMemoryPropertyDeviceLocal
+ : fuchsia_hardware_goldfish::wire::kMemoryPropertyHostVisible;
- auto createParams =
- fuchsia_hardware_goldfish::wire::CreateColorBuffer2Params::Builder(
- std::make_unique<fuchsia_hardware_goldfish::wire::
- CreateColorBuffer2Params::Frame>())
- .set_width(std::make_unique<uint32_t>(
- info.settings.image_format_constraints.min_coded_width))
- .set_height(std::make_unique<uint32_t>(
- info.settings.image_format_constraints.min_coded_height))
- .set_format(std::make_unique<
- fuchsia_hardware_goldfish::wire::ColorBufferFormatType>(
- format))
- .set_memory_property(std::make_unique<uint32_t>(memory_property))
- .build();
+ fidl::FidlAllocator allocator;
+ fuchsia_hardware_goldfish::wire::CreateColorBuffer2Params createParams(
+ allocator);
+ createParams.set_width(allocator,
+ info.settings.image_format_constraints.min_coded_width)
+ .set_height(allocator,
+ info.settings.image_format_constraints.min_coded_height)
+ .set_format(allocator, format)
+ .set_memory_property(allocator, memory_property);
auto result =
mControlDevice->CreateColorBuffer2(std::move(vmo), std::move(createParams));
@@ -3998,7 +4026,7 @@
}
if (info.settings.buffer_settings.heap ==
- fuchsia_sysmem::wire::HeapType::GOLDFISH_HOST_VISIBLE) {
+ fuchsia_sysmem::wire::HeapType::kGoldfishHostVisible) {
ALOGD(
"%s: Image uses host visible memory heap; set tiling "
"to linear to match host ImageCreateInfo",
@@ -4008,6 +4036,10 @@
}
isSysmemBackedMemory = true;
}
+
+ if (isSysmemBackedMemory) {
+ localCreateInfo.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
+ }
#endif
VkResult res;
@@ -4785,25 +4817,62 @@
VkEncoder* enc = (VkEncoder*)context;
- std::vector<std::vector<VkDescriptorImageInfo>> imageInfosPerWrite(
- descriptorWriteCount);
+ std::vector<VkDescriptorImageInfo> transformedImageInfos;
+ std::vector<VkWriteDescriptorSet> transformedWrites(descriptorWriteCount);
- std::vector<VkWriteDescriptorSet> writesWithSuppressedSamplers;
+ memcpy(transformedWrites.data(), pDescriptorWrites, sizeof(VkWriteDescriptorSet) * descriptorWriteCount);
+
+ size_t imageInfosNeeded = 0;
+ for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+ if (!isDescriptorTypeImageInfo(transformedWrites[i].descriptorType)) continue;
+ if (!transformedWrites[i].pImageInfo) continue;
+
+ imageInfosNeeded += transformedWrites[i].descriptorCount;
+ }
+
+ transformedImageInfos.resize(imageInfosNeeded);
+
+ size_t imageInfoIndex = 0;
+ for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+ if (!isDescriptorTypeImageInfo(transformedWrites[i].descriptorType)) continue;
+ if (!transformedWrites[i].pImageInfo) continue;
+
+ for (uint32_t j = 0; j < transformedWrites[i].descriptorCount; ++j) {
+ transformedImageInfos[imageInfoIndex] = transformedWrites[i].pImageInfo[j];
+ ++imageInfoIndex;
+ }
+ transformedWrites[i].pImageInfo = &transformedImageInfos[imageInfoIndex - transformedWrites[i].descriptorCount];
+ }
{
+ // Validate and filter samplers
AutoLock lock(mLock);
+ size_t imageInfoIndex = 0;
for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
- writesWithSuppressedSamplers.push_back(
- createImmutableSamplersFilteredWriteDescriptorSetLocked(
- pDescriptorWrites + i,
- imageInfosPerWrite.data() + i));
+
+ if (!isDescriptorTypeImageInfo(transformedWrites[i].descriptorType)) continue;
+ if (!transformedWrites[i].pImageInfo) continue;
+
+ bool isImmutableSampler =
+ descriptorBindingIsImmutableSampler(
+ transformedWrites[i].dstSet,
+ transformedWrites[i].dstBinding);
+
+ for (uint32_t j = 0; j < transformedWrites[i].descriptorCount; ++j) {
+ if (isImmutableSampler) {
+ transformedImageInfos[imageInfoIndex].sampler = 0;
+ }
+ transformedImageInfos[imageInfoIndex] =
+ filterNonexistentSampler(transformedImageInfos[imageInfoIndex]);
+ ++imageInfoIndex;
+ }
}
}
if (mFeatureInfo->hasVulkanBatchedDescriptorSetUpdate) {
for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
- VkDescriptorSet set = writesWithSuppressedSamplers[i].dstSet;
- doEmulatedDescriptorWrite(&writesWithSuppressedSamplers[i],
+ VkDescriptorSet set = transformedWrites[i].dstSet;
+ doEmulatedDescriptorWrite(&transformedWrites[i],
as_goldfish_VkDescriptorSet(set)->reified);
}
@@ -4814,7 +4883,7 @@
}
} else {
enc->vkUpdateDescriptorSets(
- device, descriptorWriteCount, writesWithSuppressedSamplers.data(),
+ device, descriptorWriteCount, transformedWrites.data(),
descriptorCopyCount, pDescriptorCopies, true /* do lock */);
}
}
@@ -4932,8 +5001,10 @@
const VkExternalMemoryBufferCreateInfo* extBufCiPtr =
vk_find_struct<VkExternalMemoryBufferCreateInfo>(pCreateInfo);
if (extBufCiPtr &&
+ ((extBufCiPtr->handleTypes &
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA) ||
(extBufCiPtr->handleTypes &
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)) {
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA))) {
isSysmemBackedMemory = true;
}
@@ -4943,7 +5014,7 @@
if (extBufferCollectionPtr) {
auto collection = reinterpret_cast<
- fuchsia_sysmem::BufferCollection::SyncClient*>(
+ fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(
extBufferCollectionPtr->collection);
uint32_t index = extBufferCollectionPtr->index;
@@ -4960,14 +5031,11 @@
}
if (vmo && vmo->is_valid()) {
- auto createParams =
- fuchsia_hardware_goldfish::wire::CreateBuffer2Params::Builder(
- std::make_unique<
- fuchsia_hardware_goldfish::wire::CreateBuffer2Params::Frame>())
- .set_size(std::make_unique<uint64_t>(pCreateInfo->size))
- .set_memory_property(std::make_unique<uint32_t>(
- fuchsia_hardware_goldfish::wire::MEMORY_PROPERTY_DEVICE_LOCAL))
- .build();
+ fidl::FidlAllocator allocator;
+ fuchsia_hardware_goldfish::wire::CreateBuffer2Params createParams(allocator);
+ createParams.set_size(allocator, pCreateInfo->size)
+ .set_memory_property(allocator,
+ fuchsia_hardware_goldfish::wire::kMemoryPropertyDeviceLocal);
auto result =
mControlDevice->CreateBuffer2(std::move(*vmo), std::move(createParams));
@@ -5134,11 +5202,17 @@
#ifdef VK_USE_PLATFORM_FUCHSIA
bool exportEvent = exportSemaphoreInfoPtr &&
+ ((exportSemaphoreInfoPtr->handleTypes &
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA) ||
(exportSemaphoreInfoPtr->handleTypes &
- VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA);
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA));
if (exportEvent) {
finalCreateInfo.pNext = nullptr;
+ // If we have timeline semaphores externally, leave it there.
+ const VkSemaphoreTypeCreateInfo* typeCi =
+ vk_find_struct<VkSemaphoreTypeCreateInfo>(pCreateInfo);
+ if (typeCi) finalCreateInfo.pNext = typeCi;
}
#endif
@@ -5149,6 +5223,10 @@
if (exportSyncFd) {
finalCreateInfo.pNext = nullptr;
+ // If we have timeline semaphores externally, leave it there.
+ const VkSemaphoreTypeCreateInfo* typeCi =
+ vk_find_struct<VkSemaphoreTypeCreateInfo>(pCreateInfo);
+ if (typeCi) finalCreateInfo.pNext = typeCi;
}
#endif
input_result = enc->vkCreateSemaphore(
@@ -5171,7 +5249,7 @@
info.device = device;
info.eventHandle = event_handle;
-#ifdef VK_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
info.eventKoid = getEventKoid(info.eventHandle);
#endif
@@ -6243,12 +6321,32 @@
#ifdef VK_USE_PLATFORM_FUCHSIA
if (ext_img_properties) {
- ext_img_properties->externalMemoryProperties = {
- .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
- VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
- .exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA,
- .compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA,
- };
+ const VkPhysicalDeviceExternalImageFormatInfo* ext_img_info =
+ vk_find_struct<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo);
+ if (ext_img_info) {
+ switch (static_cast<uint32_t>(ext_img_info->handleType)) {
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA:
+ ext_img_properties->externalMemoryProperties = {
+ .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
+ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
+ .exportFromImportedHandleTypes =
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA,
+ .compatibleHandleTypes =
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA,
+ };
+ break;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA:
+ ext_img_properties->externalMemoryProperties = {
+ .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
+ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
+ .exportFromImportedHandleTypes =
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA,
+ .compatibleHandleTypes =
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA,
+ };
+ break;
+ }
+ }
}
#endif
@@ -6300,6 +6398,16 @@
VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
}
+ if (pExternalSemaphoreInfo->handleType ==
+ static_cast<uint32_t>(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA)) {
+ pExternalSemaphoreProperties->compatibleHandleTypes |=
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA;
+ pExternalSemaphoreProperties->exportFromImportedHandleTypes |=
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA;
+ pExternalSemaphoreProperties->externalSemaphoreFeatures |=
+ VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
+ VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
+ }
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_ANDROID_KHR
if (pExternalSemaphoreInfo->handleType ==
@@ -6412,6 +6520,14 @@
struct goldfish_VkCommandBuffer* cb = as_goldfish_VkCommandBuffer(commandBuffer);
cb->flags = pBeginInfo->flags;
+ VkCommandBufferBeginInfo modifiedBeginInfo;
+
+ if (pBeginInfo->pInheritanceInfo && !cb->isSecondary) {
+ modifiedBeginInfo = *pBeginInfo;
+ modifiedBeginInfo.pInheritanceInfo = nullptr;
+ pBeginInfo = &modifiedBeginInfo;
+ }
+
if (!supportsDeferredCommands()) {
return enc->vkBeginCommandBuffer(commandBuffer, pBeginInfo, true /* do lock */);
}
@@ -6573,6 +6689,27 @@
decDescriptorSetLayoutRef(context, device, descriptorSetLayout, pAllocator);
}
+ VkResult on_vkAllocateCommandBuffers(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers) {
+
+ (void)input_result;
+
+ VkEncoder* enc = (VkEncoder*)context;
+ VkResult res = enc->vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers, true /* do lock */);
+ if (VK_SUCCESS != res) return res;
+
+ for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) {
+ struct goldfish_VkCommandBuffer* cb = as_goldfish_VkCommandBuffer(pCommandBuffers[i]);
+ cb->isSecondary = pAllocateInfo->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY;
+ }
+
+ return res;
+ }
+
uint32_t getApiVersionFromInstance(VkInstance instance) const {
AutoLock lock(mLock);
uint32_t api = kDefaultApiVersion;
@@ -6687,7 +6824,7 @@
}
private:
- mutable Lock mLock;
+ mutable RecursiveLock mLock;
HostVisibleMemoryVirtualizationInfo mHostVisibleMemoryVirtInfo;
std::unique_ptr<EmulatorFeatureInfo> mFeatureInfo;
std::unique_ptr<GoldfishAddressSpaceBlockProvider> mGoldfishAddressSpaceBlockProvider;
@@ -6702,9 +6839,9 @@
#ifdef VK_USE_PLATFORM_FUCHSIA
std::unique_ptr<
- fuchsia_hardware_goldfish::ControlDevice::SyncClient>
+ fidl::WireSyncClient<fuchsia_hardware_goldfish::ControlDevice>>
mControlDevice;
- std::unique_ptr<fuchsia_sysmem::Allocator::SyncClient>
+ std::unique_ptr<fidl::WireSyncClient<fuchsia_sysmem::Allocator>>
mSysmemAllocator;
#endif
@@ -6942,6 +7079,22 @@
context, physicalDevice, pMemoryProperties);
}
+void ResourceTracker::on_vkGetDeviceQueue(void* context,
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue) {
+ mImpl->on_vkGetDeviceQueue(context, device, queueFamilyIndex, queueIndex,
+ pQueue);
+}
+
+void ResourceTracker::on_vkGetDeviceQueue2(void* context,
+ VkDevice device,
+ const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue) {
+ mImpl->on_vkGetDeviceQueue2(context, device, pQueueInfo, pQueue);
+}
+
VkResult ResourceTracker::on_vkCreateInstance(
void* context,
VkResult input_result,
@@ -7689,6 +7842,15 @@
mImpl->on_vkDestroyDescriptorSetLayout(context, device, descriptorSetLayout, pAllocator);
}
+VkResult ResourceTracker::on_vkAllocateCommandBuffers(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers) {
+ return mImpl->on_vkAllocateCommandBuffers(context, input_result, device, pAllocateInfo, pCommandBuffers);
+}
+
void ResourceTracker::deviceMemoryTransform_tohost(
VkDeviceMemory* memory, uint32_t memoryCount,
VkDeviceSize* offset, uint32_t offsetCount,
diff --git a/system/vulkan_enc/ResourceTracker.h b/system/vulkan_enc/ResourceTracker.h
index cd5aa13..86e4dde 100644
--- a/system/vulkan_enc/ResourceTracker.h
+++ b/system/vulkan_enc/ResourceTracker.h
@@ -107,6 +107,15 @@
void* context,
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+ void on_vkGetDeviceQueue(void* context,
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue);
+ void on_vkGetDeviceQueue2(void* context,
+ VkDevice device,
+ const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue);
VkResult on_vkCreateInstance(
void* context,
@@ -559,6 +568,13 @@
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator);
+ VkResult on_vkAllocateCommandBuffers(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers);
+
bool isMemoryTypeHostVisible(VkDevice device, uint32_t typeIndex) const;
uint8_t* getMappedPointer(VkDeviceMemory memory);
VkDeviceSize getMappedSize(VkDeviceMemory memory);
diff --git a/system/vulkan_enc/Resources.h b/system/vulkan_enc/Resources.h
index 74f41ee..67c498e 100644
--- a/system/vulkan_enc/Resources.h
+++ b/system/vulkan_enc/Resources.h
@@ -83,7 +83,7 @@
#define GOLDFISH_VK_GET_HOST_U64_DECL(type) \
uint64_t get_host_u64_##type(type);
-GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT)
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_DECL)
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_DECL)
GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_DECL)
@@ -116,6 +116,21 @@
goldfish_vk::DescriptorSetLayoutInfo* layoutInfo;
};
+struct goldfish_VkCommandBuffer {
+ hwvulkan_dispatch_t dispatch;
+ uint64_t underlying;
+ goldfish_vk::VkEncoder* lastUsedEncoder;
+ uint32_t sequenceNumber;
+ goldfish_vk::VkEncoder* privateEncoder;
+ IOStream* privateStream;
+ uint32_t flags;
+ struct goldfish_vk_object_list* poolObjects;
+ struct goldfish_vk_object_list* subObjects;
+ struct goldfish_vk_object_list* superObjects;
+ void* userPtr;
+ bool isSecondary;
+};
+
} // extern "C"
namespace goldfish_vk {
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index 9767c6c..5660460 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -89,13 +89,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkInstanceCreateInfo*)pool->alloc(sizeof(const VkInstanceCreateInfo));
- deepcopy_VkInstanceCreateInfo(pool, pCreateInfo, (VkInstanceCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkInstanceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkInstanceCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -109,12 +109,12 @@
size_t count = 0;
size_t* countPtr = &count;
{
- count_VkInstanceCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_0;
*countPtr += 8;
@@ -127,7 +127,7 @@
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, (VkInstanceCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ 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);
@@ -135,7 +135,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_1;
@@ -178,7 +178,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -194,7 +194,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyInstance = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -216,7 +216,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkInstance((VkInstance*)&instance);
stream->flush();
@@ -367,7 +367,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceFeatures(sFeatureBits, (VkPhysicalDeviceFeatures*)(pFeatures), countPtr);
+ count_VkPhysicalDeviceFeatures(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures*)(pFeatures), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceFeatures = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures);
@@ -381,8 +381,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures), streamPtrPtr);
- unmarshal_VkPhysicalDeviceFeatures(stream, (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));
@@ -417,7 +417,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkFormat);
- count_VkFormatProperties(sFeatureBits, (VkFormatProperties*)(pFormatProperties), countPtr);
+ count_VkFormatProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties*)(pFormatProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceFormatProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties);
@@ -433,8 +433,8 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkFormat*)&local_format, sizeof(VkFormat));
*streamPtrPtr += sizeof(VkFormat);
- reservedmarshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties), streamPtrPtr);
- unmarshal_VkFormatProperties(stream, (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));
@@ -485,7 +485,7 @@
*countPtr += sizeof(VkImageTiling);
*countPtr += sizeof(VkImageUsageFlags);
*countPtr += sizeof(VkImageCreateFlags);
- count_VkImageFormatProperties(sFeatureBits, (VkImageFormatProperties*)(pImageFormatProperties), countPtr);
+ count_VkImageFormatProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties*)(pImageFormatProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties);
@@ -509,8 +509,8 @@
*streamPtrPtr += sizeof(VkImageUsageFlags);
memcpy(*streamPtrPtr, (VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
*streamPtrPtr += sizeof(VkImageCreateFlags);
- reservedmarshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties), streamPtrPtr);
- unmarshal_VkImageFormatProperties(stream, (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));
@@ -544,7 +544,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceProperties(sFeatureBits, (VkPhysicalDeviceProperties*)(pProperties), countPtr);
+ count_VkPhysicalDeviceProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties*)(pProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties);
@@ -558,8 +558,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceProperties(stream, (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));
@@ -606,7 +606,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- count_VkQueueFamilyProperties(sFeatureBits, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i), countPtr);
+ count_VkQueueFamilyProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i), countPtr);
}
}
}
@@ -642,7 +642,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- reservedmarshal_VkQueueFamilyProperties(stream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i), streamPtrPtr);
+ reservedmarshal_VkQueueFamilyProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -669,7 +669,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- unmarshal_VkQueueFamilyProperties(stream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+ unmarshal_VkQueueFamilyProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
}
}
}
@@ -709,7 +709,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceMemoryProperties(sFeatureBits, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties), countPtr);
+ count_VkPhysicalDeviceMemoryProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties);
@@ -723,8 +723,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceMemoryProperties(stream, (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));
@@ -867,13 +867,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDeviceCreateInfo*)pool->alloc(sizeof(const VkDeviceCreateInfo));
- deepcopy_VkDeviceCreateInfo(pool, pCreateInfo, (VkDeviceCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkDeviceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDeviceCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -889,12 +889,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -911,7 +911,7 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceCreateInfo(stream, (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);
@@ -919,7 +919,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -963,7 +963,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -979,7 +979,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDevice = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -1001,7 +1001,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDevice((VkDevice*)&device);
stream->flush();
@@ -1058,7 +1058,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkExtensionProperties(sFeatureBits, (VkExtensionProperties*)(pProperties + i), countPtr);
+ count_VkExtensionProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i), countPtr);
}
}
}
@@ -1120,7 +1120,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -1147,7 +1147,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
+ unmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i));
}
}
}
@@ -1222,7 +1222,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkExtensionProperties(sFeatureBits, (VkExtensionProperties*)(pProperties + i), countPtr);
+ count_VkExtensionProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i), countPtr);
}
}
}
@@ -1288,7 +1288,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -1315,7 +1315,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
+ unmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i));
}
}
}
@@ -1368,7 +1368,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkLayerProperties(sFeatureBits, (VkLayerProperties*)(pProperties + i), countPtr);
+ count_VkLayerProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i), countPtr);
}
}
}
@@ -1400,7 +1400,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -1427,7 +1427,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+ unmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i));
}
}
}
@@ -1485,7 +1485,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkLayerProperties(sFeatureBits, (VkLayerProperties*)(pProperties + i), countPtr);
+ count_VkLayerProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i), countPtr);
}
}
}
@@ -1521,7 +1521,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -1548,7 +1548,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+ unmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i));
}
}
}
@@ -1629,6 +1629,8 @@
stream->read((uint64_t*)&cgen_var_2, 8);
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)
{
@@ -1662,7 +1664,7 @@
local_pSubmits = (VkSubmitInfo*)pool->alloc(((submitCount)) * sizeof(const VkSubmitInfo));
for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
{
- deepcopy_VkSubmitInfo(pool, pSubmits + i, (VkSubmitInfo*)(local_pSubmits + i));
+ deepcopy_VkSubmitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubmits + i, (VkSubmitInfo*)(local_pSubmits + i));
}
}
local_fence = fence;
@@ -1681,7 +1683,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
{
- count_VkSubmitInfo(sFeatureBits, (VkSubmitInfo*)(local_pSubmits + i), countPtr);
+ count_VkSubmitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubmitInfo*)(local_pSubmits + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
@@ -1702,7 +1704,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
{
- reservedmarshal_VkSubmitInfo(stream, (VkSubmitInfo*)(local_pSubmits + i), streamPtrPtr);
+ 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));
@@ -1822,13 +1824,13 @@
if (pAllocateInfo)
{
local_pAllocateInfo = (VkMemoryAllocateInfo*)pool->alloc(sizeof(const VkMemoryAllocateInfo));
- deepcopy_VkMemoryAllocateInfo(pool, pAllocateInfo, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+ deepcopy_VkMemoryAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocateInfo)
@@ -1844,12 +1846,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryAllocateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -1866,7 +1868,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryAllocateInfo(stream, (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);
@@ -1874,7 +1876,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -1919,7 +1921,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, 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);
@@ -1934,7 +1936,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkFreeMemory = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -1960,7 +1962,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
stream->flush();
@@ -2020,7 +2022,7 @@
local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
- deepcopy_VkMappedMemoryRange(pool, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ deepcopy_VkMappedMemoryRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
}
}
if (local_pMemoryRanges)
@@ -2038,7 +2040,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
- count_VkMappedMemoryRange(sFeatureBits, (VkMappedMemoryRange*)(local_pMemoryRanges + i), countPtr);
+ count_VkMappedMemoryRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMappedMemoryRange*)(local_pMemoryRanges + i), countPtr);
}
}
uint32_t packetSize_vkFlushMappedMemoryRanges = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -2057,7 +2059,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
- reservedmarshal_VkMappedMemoryRange(stream, (VkMappedMemoryRange*)(local_pMemoryRanges + i), streamPtrPtr);
+ reservedmarshal_VkMappedMemoryRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMappedMemoryRange*)(local_pMemoryRanges + i), streamPtrPtr);
}
if (!sResourceTracker->usingDirectMapping())
{
@@ -2113,7 +2115,7 @@
local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
- deepcopy_VkMappedMemoryRange(pool, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ deepcopy_VkMappedMemoryRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
}
}
if (local_pMemoryRanges)
@@ -2131,7 +2133,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
- count_VkMappedMemoryRange(sFeatureBits, (VkMappedMemoryRange*)(local_pMemoryRanges + i), countPtr);
+ count_VkMappedMemoryRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMappedMemoryRange*)(local_pMemoryRanges + i), countPtr);
}
}
uint32_t packetSize_vkInvalidateMappedMemoryRanges = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -2150,7 +2152,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
- reservedmarshal_VkMappedMemoryRange(stream, (VkMappedMemoryRange*)(local_pMemoryRanges + i), streamPtrPtr);
+ 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));
@@ -2390,7 +2392,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkMemoryRequirements(sFeatureBits, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
+ count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
}
uint32_t packetSize_vkGetBufferMemoryRequirements = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements);
@@ -2408,8 +2410,8 @@
*&cgen_var_1 = get_host_u64_VkBuffer((*&local_buffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements(stream, (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));
@@ -2445,7 +2447,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkMemoryRequirements(sFeatureBits, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
+ count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
}
uint32_t packetSize_vkGetImageMemoryRequirements = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements);
@@ -2463,8 +2465,8 @@
*&cgen_var_1 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements(stream, (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));
@@ -2515,7 +2517,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- count_VkSparseImageMemoryRequirements(sFeatureBits, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i), countPtr);
+ count_VkSparseImageMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i), countPtr);
}
}
}
@@ -2555,7 +2557,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- reservedmarshal_VkSparseImageMemoryRequirements(stream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i), streamPtrPtr);
+ reservedmarshal_VkSparseImageMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -2582,7 +2584,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- unmarshal_VkSparseImageMemoryRequirements(stream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+ unmarshal_VkSparseImageMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
}
}
}
@@ -2657,7 +2659,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkSparseImageFormatProperties(sFeatureBits, (VkSparseImageFormatProperties*)(pProperties + i), countPtr);
+ count_VkSparseImageFormatProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties*)(pProperties + i), countPtr);
}
}
}
@@ -2703,7 +2705,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkSparseImageFormatProperties(stream, (VkSparseImageFormatProperties*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkSparseImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -2730,7 +2732,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkSparseImageFormatProperties(stream, (VkSparseImageFormatProperties*)(pProperties + i));
+ unmarshal_VkSparseImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties*)(pProperties + i));
}
}
}
@@ -2777,7 +2779,7 @@
local_pBindInfo = (VkBindSparseInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindSparseInfo));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- deepcopy_VkBindSparseInfo(pool, pBindInfo + i, (VkBindSparseInfo*)(local_pBindInfo + i));
+ deepcopy_VkBindSparseInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfo + i, (VkBindSparseInfo*)(local_pBindInfo + i));
}
}
local_fence = fence;
@@ -2796,7 +2798,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- count_VkBindSparseInfo(sFeatureBits, (VkBindSparseInfo*)(local_pBindInfo + i), countPtr);
+ count_VkBindSparseInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindSparseInfo*)(local_pBindInfo + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
@@ -2817,7 +2819,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- reservedmarshal_VkBindSparseInfo(stream, (VkBindSparseInfo*)(local_pBindInfo + i), streamPtrPtr);
+ 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));
@@ -2855,13 +2857,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkFenceCreateInfo*)pool->alloc(sizeof(const VkFenceCreateInfo));
- deepcopy_VkFenceCreateInfo(pool, pCreateInfo, (VkFenceCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkFenceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkFenceCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -2877,12 +2879,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkFenceCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -2899,7 +2901,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkFenceCreateInfo(stream, (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);
@@ -2907,7 +2909,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -2952,7 +2954,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -2970,7 +2972,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyFence = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -2996,7 +2998,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkFence((VkFence*)&fence);
stream->flush();
@@ -3221,13 +3223,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkSemaphoreCreateInfo*)pool->alloc(sizeof(const VkSemaphoreCreateInfo));
- deepcopy_VkSemaphoreCreateInfo(pool, pCreateInfo, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkSemaphoreCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -3243,12 +3245,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -3265,7 +3267,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreCreateInfo(stream, (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);
@@ -3273,7 +3275,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -3318,7 +3320,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -3336,7 +3338,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroySemaphore = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -3362,7 +3364,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSemaphore((VkSemaphore*)&semaphore);
stream->flush();
@@ -3395,13 +3397,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkEventCreateInfo*)pool->alloc(sizeof(const VkEventCreateInfo));
- deepcopy_VkEventCreateInfo(pool, pCreateInfo, (VkEventCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkEventCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkEventCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -3417,12 +3419,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkEventCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -3439,7 +3441,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkEventCreateInfo(stream, (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);
@@ -3447,7 +3449,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -3492,7 +3494,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -3510,7 +3512,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -3536,7 +3538,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkEvent((VkEvent*)&event);
stream->flush();
@@ -3719,13 +3721,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkQueryPoolCreateInfo*)pool->alloc(sizeof(const VkQueryPoolCreateInfo));
- deepcopy_VkQueryPoolCreateInfo(pool, pCreateInfo, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkQueryPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -3741,12 +3743,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkQueryPoolCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -3763,7 +3765,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkQueryPoolCreateInfo(stream, (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);
@@ -3771,7 +3773,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -3816,7 +3818,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -3834,7 +3836,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyQueryPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -3860,7 +3862,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkQueryPool((VkQueryPool*)&queryPool);
stream->flush();
@@ -3980,13 +3982,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkBufferCreateInfo*)pool->alloc(sizeof(const VkBufferCreateInfo));
- deepcopy_VkBufferCreateInfo(pool, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkBufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -4002,12 +4004,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -4024,7 +4026,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferCreateInfo(stream, (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);
@@ -4032,7 +4034,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4077,7 +4079,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -4095,7 +4097,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyBuffer = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -4121,7 +4123,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkBuffer((VkBuffer*)&buffer);
stream->flush();
@@ -4154,13 +4156,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkBufferViewCreateInfo*)pool->alloc(sizeof(const VkBufferViewCreateInfo));
- deepcopy_VkBufferViewCreateInfo(pool, pCreateInfo, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkBufferViewCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkBufferViewCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -4176,12 +4178,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferViewCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -4198,7 +4200,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferViewCreateInfo(stream, (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);
@@ -4206,7 +4208,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4251,7 +4253,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -4269,7 +4271,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyBufferView = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -4295,7 +4297,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkBufferView((VkBufferView*)&bufferView);
stream->flush();
@@ -4328,13 +4330,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
- deepcopy_VkImageCreateInfo(pool, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkImageCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, 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;
@@ -4351,12 +4353,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -4373,7 +4375,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageCreateInfo(stream, (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);
@@ -4381,7 +4383,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4426,7 +4428,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -4444,7 +4446,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyImage = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -4470,7 +4472,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkImage((VkImage*)&image);
stream->flush();
@@ -4504,7 +4506,7 @@
if (pSubresource)
{
local_pSubresource = (VkImageSubresource*)pool->alloc(sizeof(const VkImageSubresource));
- deepcopy_VkImageSubresource(pool, pSubresource, (VkImageSubresource*)(local_pSubresource));
+ deepcopy_VkImageSubresource(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubresource, (VkImageSubresource*)(local_pSubresource));
}
if (local_pSubresource)
{
@@ -4517,8 +4519,8 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkImageSubresource(sFeatureBits, (VkImageSubresource*)(local_pSubresource), countPtr);
- count_VkSubresourceLayout(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSubresourceLayout);
@@ -4536,9 +4538,9 @@
*&cgen_var_1 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageSubresource(stream, (VkImageSubresource*)(local_pSubresource), streamPtrPtr);
- reservedmarshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout), streamPtrPtr);
- unmarshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(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));
@@ -4572,13 +4574,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkImageViewCreateInfo*)pool->alloc(sizeof(const VkImageViewCreateInfo));
- deepcopy_VkImageViewCreateInfo(pool, pCreateInfo, (VkImageViewCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkImageViewCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImageViewCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -4594,12 +4596,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageViewCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -4616,7 +4618,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageViewCreateInfo(stream, (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);
@@ -4624,7 +4626,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4669,7 +4671,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -4687,7 +4689,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyImageView = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -4713,7 +4715,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkImageView((VkImageView*)&imageView);
stream->flush();
@@ -4746,13 +4748,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkShaderModuleCreateInfo*)pool->alloc(sizeof(const VkShaderModuleCreateInfo));
- deepcopy_VkShaderModuleCreateInfo(pool, pCreateInfo, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkShaderModuleCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -4768,12 +4770,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkShaderModuleCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -4790,7 +4792,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkShaderModuleCreateInfo(stream, (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);
@@ -4798,7 +4800,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4843,7 +4845,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -4861,7 +4863,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyShaderModule = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -4887,7 +4889,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkShaderModule((VkShaderModule*)&shaderModule);
stream->flush();
@@ -4920,13 +4922,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkPipelineCacheCreateInfo*)pool->alloc(sizeof(const VkPipelineCacheCreateInfo));
- deepcopy_VkPipelineCacheCreateInfo(pool, pCreateInfo, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkPipelineCacheCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -4942,12 +4944,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineCacheCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -4964,7 +4966,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineCacheCreateInfo(stream, (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);
@@ -4972,7 +4974,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -5017,7 +5019,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -5035,7 +5037,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyPipelineCache = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -5061,7 +5063,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkPipelineCache((VkPipelineCache*)&pipelineCache);
stream->flush();
@@ -5287,14 +5289,14 @@
local_pCreateInfos = (VkGraphicsPipelineCreateInfo*)pool->alloc(((createInfoCount)) * sizeof(const VkGraphicsPipelineCreateInfo));
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- deepcopy_VkGraphicsPipelineCreateInfo(pool, pCreateInfos + i, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
+ deepcopy_VkGraphicsPipelineCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfos)
@@ -5318,13 +5320,13 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- count_VkGraphicsPipelineCreateInfo(sFeatureBits, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i), countPtr);
+ count_VkGraphicsPipelineCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
if (((createInfoCount)))
{
@@ -5351,7 +5353,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- reservedmarshal_VkGraphicsPipelineCreateInfo(stream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i), streamPtrPtr);
+ 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;
@@ -5360,7 +5362,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
if (((createInfoCount)))
@@ -5423,14 +5425,14 @@
local_pCreateInfos = (VkComputePipelineCreateInfo*)pool->alloc(((createInfoCount)) * sizeof(const VkComputePipelineCreateInfo));
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- deepcopy_VkComputePipelineCreateInfo(pool, pCreateInfos + i, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
+ deepcopy_VkComputePipelineCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfos)
@@ -5454,13 +5456,13 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- count_VkComputePipelineCreateInfo(sFeatureBits, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i), countPtr);
+ count_VkComputePipelineCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
if (((createInfoCount)))
{
@@ -5487,7 +5489,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- reservedmarshal_VkComputePipelineCreateInfo(stream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i), streamPtrPtr);
+ 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;
@@ -5496,7 +5498,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
if (((createInfoCount)))
@@ -5551,7 +5553,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -5569,7 +5571,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyPipeline = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -5595,7 +5597,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkPipeline((VkPipeline*)&pipeline);
stream->flush();
@@ -5628,13 +5630,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkPipelineLayoutCreateInfo*)pool->alloc(sizeof(const VkPipelineLayoutCreateInfo));
- deepcopy_VkPipelineLayoutCreateInfo(pool, pCreateInfo, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkPipelineLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -5650,12 +5652,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineLayoutCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -5672,7 +5674,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineLayoutCreateInfo(stream, (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);
@@ -5680,7 +5682,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -5725,7 +5727,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -5743,7 +5745,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyPipelineLayout = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -5769,7 +5771,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkPipelineLayout((VkPipelineLayout*)&pipelineLayout);
stream->flush();
@@ -5802,13 +5804,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkSamplerCreateInfo*)pool->alloc(sizeof(const VkSamplerCreateInfo));
- deepcopy_VkSamplerCreateInfo(pool, pCreateInfo, (VkSamplerCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkSamplerCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSamplerCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -5824,12 +5826,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSamplerCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -5846,7 +5848,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSamplerCreateInfo(stream, (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);
@@ -5854,7 +5856,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -5899,7 +5901,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -5917,7 +5919,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroySampler = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -5943,7 +5945,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSampler((VkSampler*)&sampler);
stream->flush();
@@ -5976,13 +5978,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
- deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -5998,12 +6000,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -6020,7 +6022,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorSetLayoutCreateInfo(stream, (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);
@@ -6028,7 +6030,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -6073,7 +6075,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -6091,7 +6093,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDescriptorSetLayout = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -6117,7 +6119,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&descriptorSetLayout);
stream->flush();
@@ -6150,13 +6152,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDescriptorPoolCreateInfo*)pool->alloc(sizeof(const VkDescriptorPoolCreateInfo));
- deepcopy_VkDescriptorPoolCreateInfo(pool, pCreateInfo, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkDescriptorPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -6172,12 +6174,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorPoolCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -6194,7 +6196,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorPoolCreateInfo(stream, (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);
@@ -6202,7 +6204,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -6247,7 +6249,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -6265,7 +6267,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDescriptorPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -6291,7 +6293,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDescriptorPool((VkDescriptorPool*)&descriptorPool);
stream->flush();
@@ -6378,7 +6380,7 @@
if (pAllocateInfo)
{
local_pAllocateInfo = (VkDescriptorSetAllocateInfo*)pool->alloc(sizeof(const VkDescriptorSetAllocateInfo));
- deepcopy_VkDescriptorSetAllocateInfo(pool, pAllocateInfo, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+ deepcopy_VkDescriptorSetAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
}
if (local_pAllocateInfo)
{
@@ -6389,7 +6391,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorSetAllocateInfo(sFeatureBits, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo), countPtr);
+ count_VkDescriptorSetAllocateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo), countPtr);
if (pAllocateInfo->descriptorSetCount)
{
*countPtr += pAllocateInfo->descriptorSetCount * 8;
@@ -6407,7 +6409,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorSetAllocateInfo(stream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo), streamPtrPtr);
+ reservedmarshal_VkDescriptorSetAllocateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo), streamPtrPtr);
/* is handle, possibly out */;
if (pAllocateInfo->descriptorSetCount)
{
@@ -6558,7 +6560,7 @@
local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
{
- deepcopy_VkWriteDescriptorSet(pool, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
}
}
local_descriptorCopyCount = descriptorCopyCount;
@@ -6568,7 +6570,7 @@
local_pDescriptorCopies = (VkCopyDescriptorSet*)pool->alloc(((descriptorCopyCount)) * sizeof(const VkCopyDescriptorSet));
for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
{
- deepcopy_VkCopyDescriptorSet(pool, pDescriptorCopies + i, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+ deepcopy_VkCopyDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorCopies + i, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
}
}
if (local_pDescriptorWrites)
@@ -6593,12 +6595,12 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
{
- count_VkWriteDescriptorSet(sFeatureBits, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), countPtr);
+ 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, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i), countPtr);
+ count_VkCopyDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i), countPtr);
}
}
uint32_t packetSize_vkUpdateDescriptorSets = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -6617,13 +6619,13 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
{
- reservedmarshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), streamPtrPtr);
+ 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, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i), streamPtrPtr);
+ reservedmarshal_VkCopyDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i), streamPtrPtr);
}
stream->flush();
++encodeCount;;
@@ -6655,13 +6657,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkFramebufferCreateInfo*)pool->alloc(sizeof(const VkFramebufferCreateInfo));
- deepcopy_VkFramebufferCreateInfo(pool, pCreateInfo, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkFramebufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkFramebufferCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -6677,12 +6679,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkFramebufferCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -6699,7 +6701,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkFramebufferCreateInfo(stream, (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);
@@ -6707,7 +6709,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -6752,7 +6754,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -6770,7 +6772,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyFramebuffer = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -6796,7 +6798,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)&framebuffer);
stream->flush();
@@ -6829,13 +6831,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkRenderPassCreateInfo*)pool->alloc(sizeof(const VkRenderPassCreateInfo));
- deepcopy_VkRenderPassCreateInfo(pool, pCreateInfo, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkRenderPassCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkRenderPassCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -6851,12 +6853,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -6873,7 +6875,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRenderPassCreateInfo(stream, (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);
@@ -6881,7 +6883,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -6926,7 +6928,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -6944,7 +6946,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyRenderPass = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -6970,7 +6972,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkRenderPass((VkRenderPass*)&renderPass);
stream->flush();
@@ -7005,7 +7007,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkExtent2D(sFeatureBits, (VkExtent2D*)(pGranularity), countPtr);
+ count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity), countPtr);
}
uint32_t packetSize_vkGetRenderAreaGranularity = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRenderAreaGranularity);
@@ -7023,8 +7025,8 @@
*&cgen_var_1 = get_host_u64_VkRenderPass((*&local_renderPass));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity), streamPtrPtr);
- unmarshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
+ reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity), streamPtrPtr);
+ unmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity));
if (pGranularity)
{
transform_fromhost_VkExtent2D(sResourceTracker, (VkExtent2D*)(pGranularity));
@@ -7058,13 +7060,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkCommandPoolCreateInfo*)pool->alloc(sizeof(const VkCommandPoolCreateInfo));
- deepcopy_VkCommandPoolCreateInfo(pool, pCreateInfo, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkCommandPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -7080,12 +7082,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCommandPoolCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -7102,7 +7104,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCommandPoolCreateInfo(stream, (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);
@@ -7110,7 +7112,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -7155,7 +7157,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -7173,7 +7175,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyCommandPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -7199,7 +7201,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkCommandPool((VkCommandPool*)&commandPool);
stream->flush();
@@ -7286,7 +7288,7 @@
if (pAllocateInfo)
{
local_pAllocateInfo = (VkCommandBufferAllocateInfo*)pool->alloc(sizeof(const VkCommandBufferAllocateInfo));
- deepcopy_VkCommandBufferAllocateInfo(pool, pAllocateInfo, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+ deepcopy_VkCommandBufferAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
}
if (local_pAllocateInfo)
{
@@ -7297,7 +7299,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCommandBufferAllocateInfo(sFeatureBits, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo), countPtr);
+ count_VkCommandBufferAllocateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo), countPtr);
if (pAllocateInfo->commandBufferCount)
{
*countPtr += pAllocateInfo->commandBufferCount * 8;
@@ -7315,7 +7317,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCommandBufferAllocateInfo(stream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo), streamPtrPtr);
+ reservedmarshal_VkCommandBufferAllocateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo), streamPtrPtr);
/* is handle, possibly out */;
if (pAllocateInfo->commandBufferCount)
{
@@ -7455,7 +7457,7 @@
if (pBeginInfo)
{
local_pBeginInfo = (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
- deepcopy_VkCommandBufferBeginInfo(pool, pBeginInfo, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ deepcopy_VkCommandBufferBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBeginInfo, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
}
if (local_pBeginInfo)
{
@@ -7466,7 +7468,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCommandBufferBeginInfo(sFeatureBits, (VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
+ count_VkCommandBufferBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
}
uint32_t packetSize_vkBeginCommandBuffer = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkBeginCommandBuffer -= 8;
@@ -7482,7 +7484,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCommandBufferBeginInfo(stream, (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;;
@@ -7667,7 +7669,7 @@
local_pViewports = (VkViewport*)pool->alloc(((viewportCount)) * sizeof(const VkViewport));
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- deepcopy_VkViewport(pool, pViewports + i, (VkViewport*)(local_pViewports + i));
+ deepcopy_VkViewport(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewports + i, (VkViewport*)(local_pViewports + i));
}
}
if (local_pViewports)
@@ -7686,7 +7688,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- count_VkViewport(sFeatureBits, (VkViewport*)(local_pViewports + i), countPtr);
+ count_VkViewport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(local_pViewports + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetViewport = 4 + 4 + count;
@@ -7709,7 +7711,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- reservedmarshal_VkViewport(stream, (VkViewport*)(local_pViewports + i), streamPtrPtr);
+ reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(local_pViewports + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -7745,7 +7747,7 @@
local_pScissors = (VkRect2D*)pool->alloc(((scissorCount)) * sizeof(const VkRect2D));
for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
{
- deepcopy_VkRect2D(pool, pScissors + i, (VkRect2D*)(local_pScissors + i));
+ deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pScissors + i, (VkRect2D*)(local_pScissors + i));
}
}
if (local_pScissors)
@@ -7764,7 +7766,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
{
- count_VkRect2D(sFeatureBits, (VkRect2D*)(local_pScissors + i), countPtr);
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pScissors + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetScissor = 4 + 4 + count;
@@ -7787,7 +7789,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
{
- reservedmarshal_VkRect2D(stream, (VkRect2D*)(local_pScissors + i), streamPtrPtr);
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pScissors + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -8801,7 +8803,7 @@
local_pRegions = (VkBufferCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferCopy));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- deepcopy_VkBufferCopy(pool, pRegions + i, (VkBufferCopy*)(local_pRegions + i));
+ deepcopy_VkBufferCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkBufferCopy*)(local_pRegions + i));
}
}
if (local_pRegions)
@@ -8823,7 +8825,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- count_VkBufferCopy(sFeatureBits, (VkBufferCopy*)(local_pRegions + i), countPtr);
+ count_VkBufferCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCopy*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdCopyBuffer = 4 + 4 + count;
@@ -8852,7 +8854,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- reservedmarshal_VkBufferCopy(stream, (VkBufferCopy*)(local_pRegions + i), streamPtrPtr);
+ reservedmarshal_VkBufferCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCopy*)(local_pRegions + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -8897,7 +8899,7 @@
local_pRegions = (VkImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkImageCopy));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- deepcopy_VkImageCopy(pool, pRegions + i, (VkImageCopy*)(local_pRegions + i));
+ deepcopy_VkImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkImageCopy*)(local_pRegions + i));
}
}
if (local_pRegions)
@@ -8921,7 +8923,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- count_VkImageCopy(sFeatureBits, (VkImageCopy*)(local_pRegions + i), countPtr);
+ count_VkImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCopy*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdCopyImage = 4 + 4 + count;
@@ -8954,7 +8956,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- reservedmarshal_VkImageCopy(stream, (VkImageCopy*)(local_pRegions + i), streamPtrPtr);
+ reservedmarshal_VkImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCopy*)(local_pRegions + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -9001,7 +9003,7 @@
local_pRegions = (VkImageBlit*)pool->alloc(((regionCount)) * sizeof(const VkImageBlit));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- deepcopy_VkImageBlit(pool, pRegions + i, (VkImageBlit*)(local_pRegions + i));
+ deepcopy_VkImageBlit(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkImageBlit*)(local_pRegions + i));
}
}
local_filter = filter;
@@ -9026,7 +9028,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- count_VkImageBlit(sFeatureBits, (VkImageBlit*)(local_pRegions + i), countPtr);
+ count_VkImageBlit(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageBlit*)(local_pRegions + i), countPtr);
}
*countPtr += sizeof(VkFilter);
}
@@ -9060,7 +9062,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- reservedmarshal_VkImageBlit(stream, (VkImageBlit*)(local_pRegions + i), streamPtrPtr);
+ reservedmarshal_VkImageBlit(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageBlit*)(local_pRegions + i), streamPtrPtr);
}
memcpy(*streamPtrPtr, (VkFilter*)&local_filter, sizeof(VkFilter));
*streamPtrPtr += sizeof(VkFilter);
@@ -9104,7 +9106,7 @@
local_pRegions = (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- deepcopy_VkBufferImageCopy(pool, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
+ deepcopy_VkBufferImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
}
}
if (local_pRegions)
@@ -9127,7 +9129,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- count_VkBufferImageCopy(sFeatureBits, (VkBufferImageCopy*)(local_pRegions + i), countPtr);
+ count_VkBufferImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdCopyBufferToImage = 4 + 4 + count;
@@ -9158,7 +9160,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- reservedmarshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
+ reservedmarshal_VkBufferImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -9200,7 +9202,7 @@
local_pRegions = (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- deepcopy_VkBufferImageCopy(pool, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
+ deepcopy_VkBufferImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
}
}
if (local_pRegions)
@@ -9223,7 +9225,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- count_VkBufferImageCopy(sFeatureBits, (VkBufferImageCopy*)(local_pRegions + i), countPtr);
+ count_VkBufferImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdCopyImageToBuffer = 4 + 4 + count;
@@ -9254,7 +9256,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- reservedmarshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
+ reservedmarshal_VkBufferImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -9427,7 +9429,7 @@
if (pColor)
{
local_pColor = (VkClearColorValue*)pool->alloc(sizeof(const VkClearColorValue));
- deepcopy_VkClearColorValue(pool, pColor, (VkClearColorValue*)(local_pColor));
+ deepcopy_VkClearColorValue(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pColor, (VkClearColorValue*)(local_pColor));
}
local_rangeCount = rangeCount;
local_pRanges = nullptr;
@@ -9436,7 +9438,7 @@
local_pRanges = (VkImageSubresourceRange*)pool->alloc(((rangeCount)) * sizeof(const VkImageSubresourceRange));
for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
{
- deepcopy_VkImageSubresourceRange(pool, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
+ deepcopy_VkImageSubresourceRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
}
}
if (local_pColor)
@@ -9458,11 +9460,11 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(VkImageLayout);
- count_VkClearColorValue(sFeatureBits, (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, (VkImageSubresourceRange*)(local_pRanges + i), countPtr);
+ count_VkImageSubresourceRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(local_pRanges + i), countPtr);
}
}
uint32_t packetSize_vkCmdClearColorImage = 4 + 4 + count;
@@ -9485,12 +9487,12 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
*streamPtrPtr += sizeof(VkImageLayout);
- reservedmarshal_VkClearColorValue(stream, (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, (VkImageSubresourceRange*)(local_pRanges + i), streamPtrPtr);
+ reservedmarshal_VkImageSubresourceRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(local_pRanges + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -9528,7 +9530,7 @@
if (pDepthStencil)
{
local_pDepthStencil = (VkClearDepthStencilValue*)pool->alloc(sizeof(const VkClearDepthStencilValue));
- deepcopy_VkClearDepthStencilValue(pool, pDepthStencil, (VkClearDepthStencilValue*)(local_pDepthStencil));
+ deepcopy_VkClearDepthStencilValue(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDepthStencil, (VkClearDepthStencilValue*)(local_pDepthStencil));
}
local_rangeCount = rangeCount;
local_pRanges = nullptr;
@@ -9537,7 +9539,7 @@
local_pRanges = (VkImageSubresourceRange*)pool->alloc(((rangeCount)) * sizeof(const VkImageSubresourceRange));
for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
{
- deepcopy_VkImageSubresourceRange(pool, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
+ deepcopy_VkImageSubresourceRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
}
}
if (local_pDepthStencil)
@@ -9559,11 +9561,11 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(VkImageLayout);
- count_VkClearDepthStencilValue(sFeatureBits, (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, (VkImageSubresourceRange*)(local_pRanges + i), countPtr);
+ count_VkImageSubresourceRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(local_pRanges + i), countPtr);
}
}
uint32_t packetSize_vkCmdClearDepthStencilImage = 4 + 4 + count;
@@ -9586,12 +9588,12 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
*streamPtrPtr += sizeof(VkImageLayout);
- reservedmarshal_VkClearDepthStencilValue(stream, (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, (VkImageSubresourceRange*)(local_pRanges + i), streamPtrPtr);
+ reservedmarshal_VkImageSubresourceRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(local_pRanges + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -9628,7 +9630,7 @@
local_pAttachments = (VkClearAttachment*)pool->alloc(((attachmentCount)) * sizeof(const VkClearAttachment));
for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
{
- deepcopy_VkClearAttachment(pool, pAttachments + i, (VkClearAttachment*)(local_pAttachments + i));
+ deepcopy_VkClearAttachment(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAttachments + i, (VkClearAttachment*)(local_pAttachments + i));
}
}
local_rectCount = rectCount;
@@ -9638,7 +9640,7 @@
local_pRects = (VkClearRect*)pool->alloc(((rectCount)) * sizeof(const VkClearRect));
for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
{
- deepcopy_VkClearRect(pool, pRects + i, (VkClearRect*)(local_pRects + i));
+ deepcopy_VkClearRect(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRects + i, (VkClearRect*)(local_pRects + i));
}
}
if (local_pAttachments)
@@ -9663,12 +9665,12 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
{
- count_VkClearAttachment(sFeatureBits, (VkClearAttachment*)(local_pAttachments + i), countPtr);
+ 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, (VkClearRect*)(local_pRects + i), countPtr);
+ count_VkClearRect(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearRect*)(local_pRects + i), countPtr);
}
}
uint32_t packetSize_vkCmdClearAttachments = 4 + 4 + count;
@@ -9689,13 +9691,13 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
{
- reservedmarshal_VkClearAttachment(stream, (VkClearAttachment*)(local_pAttachments + i), streamPtrPtr);
+ 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, (VkClearRect*)(local_pRects + i), streamPtrPtr);
+ reservedmarshal_VkClearRect(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearRect*)(local_pRects + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -9740,7 +9742,7 @@
local_pRegions = (VkImageResolve*)pool->alloc(((regionCount)) * sizeof(const VkImageResolve));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- deepcopy_VkImageResolve(pool, pRegions + i, (VkImageResolve*)(local_pRegions + i));
+ deepcopy_VkImageResolve(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkImageResolve*)(local_pRegions + i));
}
}
if (local_pRegions)
@@ -9764,7 +9766,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- count_VkImageResolve(sFeatureBits, (VkImageResolve*)(local_pRegions + i), countPtr);
+ count_VkImageResolve(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageResolve*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdResolveImage = 4 + 4 + count;
@@ -9797,7 +9799,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
- reservedmarshal_VkImageResolve(stream, (VkImageResolve*)(local_pRegions + i), streamPtrPtr);
+ reservedmarshal_VkImageResolve(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageResolve*)(local_pRegions + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -9961,7 +9963,7 @@
local_pMemoryBarriers = (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
{
- deepcopy_VkMemoryBarrier(pool, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ deepcopy_VkMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
}
}
local_bufferMemoryBarrierCount = bufferMemoryBarrierCount;
@@ -9971,7 +9973,7 @@
local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
{
- deepcopy_VkBufferMemoryBarrier(pool, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ deepcopy_VkBufferMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
}
}
local_imageMemoryBarrierCount = imageMemoryBarrierCount;
@@ -9981,7 +9983,7 @@
local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
{
- deepcopy_VkImageMemoryBarrier(pool, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ deepcopy_VkImageMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
}
}
if (local_pMemoryBarriers)
@@ -10020,17 +10022,17 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
{
- count_VkMemoryBarrier(sFeatureBits, (VkMemoryBarrier*)(local_pMemoryBarriers + i), countPtr);
+ 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, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), countPtr);
+ 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, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), countPtr);
+ count_VkImageMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), countPtr);
}
}
uint32_t packetSize_vkCmdWaitEvents = 4 + 4 + count;
@@ -10067,19 +10069,19 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
{
- reservedmarshal_VkMemoryBarrier(stream, (VkMemoryBarrier*)(local_pMemoryBarriers + i), streamPtrPtr);
+ 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, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), streamPtrPtr);
+ 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, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
+ reservedmarshal_VkImageMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -10129,7 +10131,7 @@
local_pMemoryBarriers = (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
{
- deepcopy_VkMemoryBarrier(pool, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ deepcopy_VkMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
}
}
local_bufferMemoryBarrierCount = bufferMemoryBarrierCount;
@@ -10139,7 +10141,7 @@
local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
{
- deepcopy_VkBufferMemoryBarrier(pool, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ deepcopy_VkBufferMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
}
}
local_imageMemoryBarrierCount = imageMemoryBarrierCount;
@@ -10149,7 +10151,7 @@
local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
{
- deepcopy_VkImageMemoryBarrier(pool, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ deepcopy_VkImageMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
}
}
if (local_pMemoryBarriers)
@@ -10184,17 +10186,17 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
{
- count_VkMemoryBarrier(sFeatureBits, (VkMemoryBarrier*)(local_pMemoryBarriers + i), countPtr);
+ 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, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), countPtr);
+ 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, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), countPtr);
+ count_VkImageMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), countPtr);
}
}
uint32_t packetSize_vkCmdPipelineBarrier = 4 + 4 + count;
@@ -10221,19 +10223,19 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
{
- reservedmarshal_VkMemoryBarrier(stream, (VkMemoryBarrier*)(local_pMemoryBarriers + i), streamPtrPtr);
+ 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, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), streamPtrPtr);
+ 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, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
+ reservedmarshal_VkImageMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -10663,7 +10665,7 @@
if (pRenderPassBegin)
{
local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
- deepcopy_VkRenderPassBeginInfo(pool, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ deepcopy_VkRenderPassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
}
local_contents = contents;
if (local_pRenderPassBegin)
@@ -10675,7 +10677,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassBeginInfo(sFeatureBits, (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;
@@ -10692,7 +10694,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkRenderPassBeginInfo(stream, (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;;
@@ -10915,7 +10917,7 @@
local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- deepcopy_VkBindBufferMemoryInfo(pool, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ deepcopy_VkBindBufferMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
}
}
if (local_pBindInfos)
@@ -10933,7 +10935,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- count_VkBindBufferMemoryInfo(sFeatureBits, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), countPtr);
+ count_VkBindBufferMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), countPtr);
}
}
uint32_t packetSize_vkBindBufferMemory2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -10952,7 +10954,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- reservedmarshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), streamPtrPtr);
+ 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));
@@ -10988,7 +10990,7 @@
local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- deepcopy_VkBindImageMemoryInfo(pool, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ deepcopy_VkBindImageMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
}
}
if (local_pBindInfos)
@@ -11006,7 +11008,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- count_VkBindImageMemoryInfo(sFeatureBits, (VkBindImageMemoryInfo*)(local_pBindInfos + i), countPtr);
+ count_VkBindImageMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindImageMemoryInfo*)(local_pBindInfos + i), countPtr);
}
}
uint32_t packetSize_vkBindImageMemory2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -11025,7 +11027,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- reservedmarshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i), streamPtrPtr);
+ 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));
@@ -11254,7 +11256,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
{
- count_VkPhysicalDeviceGroupProperties(sFeatureBits, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), countPtr);
+ count_VkPhysicalDeviceGroupProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), countPtr);
}
}
}
@@ -11290,7 +11292,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
{
- reservedmarshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceGroupProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -11317,7 +11319,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
{
- unmarshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ unmarshal_VkPhysicalDeviceGroupProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
}
}
}
@@ -11361,7 +11363,7 @@
if (pInfo)
{
local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
- deepcopy_VkImageMemoryRequirementsInfo2(pool, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ deepcopy_VkImageMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
}
if (local_pInfo)
{
@@ -11372,8 +11374,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageMemoryRequirementsInfo2(sFeatureBits, (VkImageMemoryRequirementsInfo2*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements2);
@@ -11387,9 +11389,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, (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));
@@ -11421,7 +11423,7 @@
if (pInfo)
{
local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
- deepcopy_VkBufferMemoryRequirementsInfo2(pool, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ deepcopy_VkBufferMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
}
if (local_pInfo)
{
@@ -11432,8 +11434,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferMemoryRequirementsInfo2(sFeatureBits, (VkBufferMemoryRequirementsInfo2*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements2);
@@ -11447,9 +11449,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, (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));
@@ -11482,7 +11484,7 @@
if (pInfo)
{
local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
- deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
}
if (local_pInfo)
{
@@ -11493,7 +11495,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageSparseMemoryRequirementsInfo2(sFeatureBits, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), countPtr);
+ count_VkImageSparseMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pSparseMemoryRequirementCount)
@@ -11508,7 +11510,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- count_VkSparseImageMemoryRequirements2(sFeatureBits, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), countPtr);
+ count_VkSparseImageMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), countPtr);
}
}
}
@@ -11525,7 +11527,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageSparseMemoryRequirementsInfo2(stream, (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);
@@ -11545,7 +11547,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- reservedmarshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
+ reservedmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -11572,7 +11574,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- unmarshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ unmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
}
}
}
@@ -11612,7 +11614,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceFeatures2(sFeatureBits, (VkPhysicalDeviceFeatures2*)(pFeatures), countPtr);
+ count_VkPhysicalDeviceFeatures2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceFeatures2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures2);
@@ -11626,8 +11628,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures), streamPtrPtr);
- unmarshal_VkPhysicalDeviceFeatures2(stream, (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));
@@ -11658,7 +11660,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceProperties2(sFeatureBits, (VkPhysicalDeviceProperties2*)(pProperties), countPtr);
+ count_VkPhysicalDeviceProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties2*)(pProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties2);
@@ -11672,8 +11674,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceProperties2(stream, (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));
@@ -11709,7 +11711,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkFormat);
- count_VkFormatProperties2(sFeatureBits, (VkFormatProperties2*)(pFormatProperties), countPtr);
+ count_VkFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties2*)(pFormatProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties2);
@@ -11725,8 +11727,8 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkFormat*)&local_format, sizeof(VkFormat));
*streamPtrPtr += sizeof(VkFormat);
- reservedmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties), streamPtrPtr);
- unmarshal_VkFormatProperties2(stream, (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));
@@ -11758,7 +11760,7 @@
if (pImageFormatInfo)
{
local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
- deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
}
if (local_pImageFormatInfo)
{
@@ -11769,8 +11771,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceImageFormatInfo2(sFeatureBits, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), countPtr);
- count_VkImageFormatProperties2(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties2);
@@ -11784,9 +11786,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), streamPtrPtr);
- reservedmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties), streamPtrPtr);
- unmarshal_VkImageFormatProperties2(stream, (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));
@@ -11835,7 +11837,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- count_VkQueueFamilyProperties2(sFeatureBits, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), countPtr);
+ count_VkQueueFamilyProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), countPtr);
}
}
}
@@ -11871,7 +11873,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- reservedmarshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
+ reservedmarshal_VkQueueFamilyProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -11898,7 +11900,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- unmarshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ unmarshal_VkQueueFamilyProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
}
}
}
@@ -11938,7 +11940,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceMemoryProperties2(sFeatureBits, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), countPtr);
+ count_VkPhysicalDeviceMemoryProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties2);
@@ -11952,8 +11954,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (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));
@@ -11987,7 +11989,7 @@
if (pFormatInfo)
{
local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
- deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
}
if (local_pFormatInfo)
{
@@ -11998,7 +12000,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSparseImageFormatInfo2(sFeatureBits, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), countPtr);
+ count_VkPhysicalDeviceSparseImageFormatInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pPropertyCount)
@@ -12013,7 +12015,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkSparseImageFormatProperties2(sFeatureBits, (VkSparseImageFormatProperties2*)(pProperties + i), countPtr);
+ count_VkSparseImageFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i), countPtr);
}
}
}
@@ -12030,7 +12032,7 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (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);
@@ -12050,7 +12052,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkSparseImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -12077,7 +12079,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+ unmarshal_VkSparseImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i));
}
}
}
@@ -12172,7 +12174,7 @@
if (pQueueInfo)
{
local_pQueueInfo = (VkDeviceQueueInfo2*)pool->alloc(sizeof(const VkDeviceQueueInfo2));
- deepcopy_VkDeviceQueueInfo2(pool, pQueueInfo, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+ deepcopy_VkDeviceQueueInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pQueueInfo, (VkDeviceQueueInfo2*)(local_pQueueInfo));
}
if (local_pQueueInfo)
{
@@ -12183,7 +12185,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceQueueInfo2(sFeatureBits, (VkDeviceQueueInfo2*)(local_pQueueInfo), countPtr);
+ count_VkDeviceQueueInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceQueueInfo2*)(local_pQueueInfo), countPtr);
uint64_t cgen_var_1;
*countPtr += 8;
}
@@ -12199,7 +12201,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceQueueInfo2(stream, (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));
@@ -12209,6 +12211,7 @@
uint64_t cgen_var_2;
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)
{
@@ -12238,13 +12241,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
- deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -12260,12 +12263,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSamplerYcbcrConversionCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -12282,7 +12285,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSamplerYcbcrConversionCreateInfo(stream, (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);
@@ -12290,7 +12293,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -12335,7 +12338,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -12353,7 +12356,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroySamplerYcbcrConversion = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -12379,7 +12382,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
stream->flush();
@@ -12412,13 +12415,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
- deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -12434,12 +12437,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorUpdateTemplateCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -12456,7 +12459,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(stream, (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);
@@ -12464,7 +12467,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -12510,7 +12513,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -12528,7 +12531,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDescriptorUpdateTemplate = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -12554,7 +12557,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
stream->flush();
@@ -12662,7 +12665,7 @@
if (pExternalBufferInfo)
{
local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
- deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
}
if (local_pExternalBufferInfo)
{
@@ -12674,8 +12677,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalBufferInfo(sFeatureBits, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), countPtr);
- count_VkExternalBufferProperties(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalBufferProperties);
@@ -12689,9 +12692,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), streamPtrPtr);
- reservedmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties), streamPtrPtr);
- unmarshal_VkExternalBufferProperties(stream, (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);
@@ -12724,7 +12727,7 @@
if (pExternalFenceInfo)
{
local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
- deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
}
if (local_pExternalFenceInfo)
{
@@ -12735,8 +12738,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalFenceInfo(sFeatureBits, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), countPtr);
- count_VkExternalFenceProperties(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalFenceProperties);
@@ -12750,9 +12753,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), streamPtrPtr);
- reservedmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties), streamPtrPtr);
- unmarshal_VkExternalFenceProperties(stream, (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));
@@ -12784,7 +12787,7 @@
if (pExternalSemaphoreInfo)
{
local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
- deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
}
if (local_pExternalSemaphoreInfo)
{
@@ -12795,8 +12798,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalSemaphoreInfo(sFeatureBits, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), countPtr);
- count_VkExternalSemaphoreProperties(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties);
@@ -12810,9 +12813,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), streamPtrPtr);
- reservedmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), streamPtrPtr);
- unmarshal_VkExternalSemaphoreProperties(stream, (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));
@@ -12845,7 +12848,7 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
- deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
if (local_pCreateInfo)
{
@@ -12856,8 +12859,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), countPtr);
- count_VkDescriptorSetLayoutSupport(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDescriptorSetLayoutSupport);
@@ -12871,9 +12874,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), streamPtrPtr);
- reservedmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport), streamPtrPtr);
- unmarshal_VkDescriptorSetLayoutSupport(stream, (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));
@@ -13073,13 +13076,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkRenderPassCreateInfo2*)pool->alloc(sizeof(const VkRenderPassCreateInfo2));
- deepcopy_VkRenderPassCreateInfo2(pool, pCreateInfo, (VkRenderPassCreateInfo2*)(local_pCreateInfo));
+ deepcopy_VkRenderPassCreateInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkRenderPassCreateInfo2*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -13095,12 +13098,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassCreateInfo2(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -13117,7 +13120,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRenderPassCreateInfo2(stream, (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);
@@ -13125,7 +13128,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -13167,13 +13170,13 @@
if (pRenderPassBegin)
{
local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
- deepcopy_VkRenderPassBeginInfo(pool, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ 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, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
if (local_pRenderPassBegin)
{
@@ -13188,8 +13191,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassBeginInfo(sFeatureBits, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), countPtr);
- count_VkSubpassBeginInfo(sFeatureBits, (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;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderPass2 -= 8;
@@ -13205,8 +13208,8 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), streamPtrPtr);
- reservedmarshal_VkSubpassBeginInfo(stream, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), streamPtrPtr);
+ 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)
{
@@ -13235,13 +13238,13 @@
if (pSubpassBeginInfo)
{
local_pSubpassBeginInfo = (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
- deepcopy_VkSubpassBeginInfo(pool, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
local_pSubpassEndInfo = nullptr;
if (pSubpassEndInfo)
{
local_pSubpassEndInfo = (VkSubpassEndInfo*)pool->alloc(sizeof(const VkSubpassEndInfo));
- deepcopy_VkSubpassEndInfo(pool, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
if (local_pSubpassBeginInfo)
{
@@ -13256,8 +13259,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSubpassBeginInfo(sFeatureBits, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
- count_VkSubpassEndInfo(sFeatureBits, (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;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdNextSubpass2 -= 8;
@@ -13273,8 +13276,8 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSubpassBeginInfo(stream, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), streamPtrPtr);
- reservedmarshal_VkSubpassEndInfo(stream, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
+ 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)
{
@@ -13301,7 +13304,7 @@
if (pSubpassEndInfo)
{
local_pSubpassEndInfo = (VkSubpassEndInfo*)pool->alloc(sizeof(const VkSubpassEndInfo));
- deepcopy_VkSubpassEndInfo(pool, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
if (local_pSubpassEndInfo)
{
@@ -13312,7 +13315,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSubpassEndInfo(sFeatureBits, (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
+ count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdEndRenderPass2 = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderPass2 -= 8;
@@ -13328,7 +13331,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSubpassEndInfo(stream, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
+ reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -13472,7 +13475,7 @@
if (pWaitInfo)
{
local_pWaitInfo = (VkSemaphoreWaitInfo*)pool->alloc(sizeof(const VkSemaphoreWaitInfo));
- deepcopy_VkSemaphoreWaitInfo(pool, pWaitInfo, (VkSemaphoreWaitInfo*)(local_pWaitInfo));
+ deepcopy_VkSemaphoreWaitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pWaitInfo, (VkSemaphoreWaitInfo*)(local_pWaitInfo));
}
local_timeout = timeout;
if (local_pWaitInfo)
@@ -13484,7 +13487,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreWaitInfo(sFeatureBits, (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;
@@ -13499,7 +13502,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreWaitInfo(stream, (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;
@@ -13531,7 +13534,7 @@
if (pSignalInfo)
{
local_pSignalInfo = (VkSemaphoreSignalInfo*)pool->alloc(sizeof(const VkSemaphoreSignalInfo));
- deepcopy_VkSemaphoreSignalInfo(pool, pSignalInfo, (VkSemaphoreSignalInfo*)(local_pSignalInfo));
+ deepcopy_VkSemaphoreSignalInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSignalInfo, (VkSemaphoreSignalInfo*)(local_pSignalInfo));
}
if (local_pSignalInfo)
{
@@ -13542,7 +13545,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreSignalInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkSignalSemaphore);
@@ -13556,7 +13559,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreSignalInfo(stream, (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;;
@@ -13586,7 +13589,7 @@
if (pInfo)
{
local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
}
if (local_pInfo)
{
@@ -13597,7 +13600,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferDeviceAddress);
@@ -13611,7 +13614,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, (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;;
@@ -13641,7 +13644,7 @@
if (pInfo)
{
local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
}
if (local_pInfo)
{
@@ -13652,7 +13655,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferOpaqueCaptureAddress);
@@ -13666,7 +13669,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, (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;;
@@ -13696,7 +13699,7 @@
if (pInfo)
{
local_pInfo = (VkDeviceMemoryOpaqueCaptureAddressInfo*)pool->alloc(sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo));
- deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(pool, pInfo, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
+ deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
}
if (local_pInfo)
{
@@ -13707,7 +13710,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceMemoryOpaqueCaptureAddressInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceMemoryOpaqueCaptureAddress);
@@ -13721,7 +13724,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(stream, (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;;
@@ -13756,7 +13759,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -13774,7 +13777,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroySurfaceKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -13800,7 +13803,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&surface);
stream->flush();
@@ -13896,7 +13899,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkSurfaceCapabilitiesKHR(sFeatureBits, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities), countPtr);
+ count_VkSurfaceCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
@@ -13914,8 +13917,8 @@
*&cgen_var_1 = get_host_u64_VkSurfaceKHR((*&local_surface));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities), streamPtrPtr);
- unmarshal_VkSurfaceCapabilitiesKHR(stream, (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));
@@ -13969,7 +13972,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
{
- count_VkSurfaceFormatKHR(sFeatureBits, (VkSurfaceFormatKHR*)(pSurfaceFormats + i), countPtr);
+ count_VkSurfaceFormatKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormatKHR*)(pSurfaceFormats + i), countPtr);
}
}
}
@@ -14009,7 +14012,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
{
- reservedmarshal_VkSurfaceFormatKHR(stream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i), streamPtrPtr);
+ reservedmarshal_VkSurfaceFormatKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormatKHR*)(pSurfaceFormats + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -14036,7 +14039,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
{
- unmarshal_VkSurfaceFormatKHR(stream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+ unmarshal_VkSurfaceFormatKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
}
}
}
@@ -14193,13 +14196,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkSwapchainCreateInfoKHR*)pool->alloc(sizeof(const VkSwapchainCreateInfoKHR));
- deepcopy_VkSwapchainCreateInfoKHR(pool, pCreateInfo, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkSwapchainCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -14215,12 +14218,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSwapchainCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -14237,7 +14240,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSwapchainCreateInfoKHR(stream, (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);
@@ -14245,7 +14248,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -14290,7 +14293,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -14308,7 +14311,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroySwapchainKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -14334,7 +14337,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&swapchain);
stream->flush();
@@ -14571,7 +14574,7 @@
if (pPresentInfo)
{
local_pPresentInfo = (VkPresentInfoKHR*)pool->alloc(sizeof(const VkPresentInfoKHR));
- deepcopy_VkPresentInfoKHR(pool, pPresentInfo, (VkPresentInfoKHR*)(local_pPresentInfo));
+ deepcopy_VkPresentInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPresentInfo, (VkPresentInfoKHR*)(local_pPresentInfo));
}
if (local_pPresentInfo)
{
@@ -14582,7 +14585,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPresentInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkQueuePresentKHR);
@@ -14596,7 +14599,7 @@
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPresentInfoKHR(stream, (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;;
@@ -14626,7 +14629,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceGroupPresentCapabilitiesKHR(sFeatureBits, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities), countPtr);
+ count_VkDeviceGroupPresentCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities), countPtr);
}
uint32_t packetSize_vkGetDeviceGroupPresentCapabilitiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceGroupPresentCapabilitiesKHR);
@@ -14640,8 +14643,8 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities), streamPtrPtr);
- unmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (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));
@@ -14773,7 +14776,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
{
- count_VkRect2D(sFeatureBits, (VkRect2D*)(pRects + i), countPtr);
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pRects + i), countPtr);
}
}
}
@@ -14813,7 +14816,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
{
- reservedmarshal_VkRect2D(stream, (VkRect2D*)(pRects + i), streamPtrPtr);
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pRects + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -14840,7 +14843,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
{
- unmarshal_VkRect2D(stream, (VkRect2D*)(pRects + i));
+ unmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pRects + i));
}
}
}
@@ -14884,7 +14887,7 @@
if (pAcquireInfo)
{
local_pAcquireInfo = (VkAcquireNextImageInfoKHR*)pool->alloc(sizeof(const VkAcquireNextImageInfoKHR));
- deepcopy_VkAcquireNextImageInfoKHR(pool, pAcquireInfo, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+ deepcopy_VkAcquireNextImageInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAcquireInfo, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
}
if (local_pAcquireInfo)
{
@@ -14895,7 +14898,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAcquireNextImageInfoKHR(sFeatureBits, (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;
@@ -14910,7 +14913,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAcquireNextImageInfoKHR(stream, (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));
@@ -14960,7 +14963,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkDisplayPropertiesKHR(sFeatureBits, (VkDisplayPropertiesKHR*)(pProperties + i), countPtr);
+ count_VkDisplayPropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPropertiesKHR*)(pProperties + i), countPtr);
}
}
}
@@ -14996,7 +14999,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkDisplayPropertiesKHR(stream, (VkDisplayPropertiesKHR*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkDisplayPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPropertiesKHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -15023,7 +15026,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkDisplayPropertiesKHR(stream, (VkDisplayPropertiesKHR*)(pProperties + i));
+ unmarshal_VkDisplayPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPropertiesKHR*)(pProperties + i));
}
}
}
@@ -15081,7 +15084,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkDisplayPlanePropertiesKHR(sFeatureBits, (VkDisplayPlanePropertiesKHR*)(pProperties + i), countPtr);
+ count_VkDisplayPlanePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlanePropertiesKHR*)(pProperties + i), countPtr);
}
}
}
@@ -15117,7 +15120,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkDisplayPlanePropertiesKHR(stream, (VkDisplayPlanePropertiesKHR*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkDisplayPlanePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlanePropertiesKHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -15144,7 +15147,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkDisplayPlanePropertiesKHR(stream, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+ unmarshal_VkDisplayPlanePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
}
}
}
@@ -15332,7 +15335,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkDisplayModePropertiesKHR(sFeatureBits, (VkDisplayModePropertiesKHR*)(pProperties + i), countPtr);
+ count_VkDisplayModePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModePropertiesKHR*)(pProperties + i), countPtr);
}
}
}
@@ -15372,7 +15375,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkDisplayModePropertiesKHR(stream, (VkDisplayModePropertiesKHR*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkDisplayModePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModePropertiesKHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -15399,7 +15402,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkDisplayModePropertiesKHR(stream, (VkDisplayModePropertiesKHR*)(pProperties + i));
+ unmarshal_VkDisplayModePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModePropertiesKHR*)(pProperties + i));
}
}
}
@@ -15448,13 +15451,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDisplayModeCreateInfoKHR*)pool->alloc(sizeof(const VkDisplayModeCreateInfoKHR));
- deepcopy_VkDisplayModeCreateInfoKHR(pool, pCreateInfo, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkDisplayModeCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -15472,12 +15475,12 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkDisplayModeCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_2;
*countPtr += 8;
@@ -15498,7 +15501,7 @@
*&cgen_var_1 = get_host_u64_VkDisplayKHR((*&local_display));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplayModeCreateInfoKHR(stream, (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);
@@ -15506,7 +15509,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_3;
@@ -15557,7 +15560,7 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- count_VkDisplayPlaneCapabilitiesKHR(sFeatureBits, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities), countPtr);
+ count_VkDisplayPlaneCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities), countPtr);
}
uint32_t packetSize_vkGetDisplayPlaneCapabilitiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDisplayPlaneCapabilitiesKHR);
@@ -15577,8 +15580,8 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_planeIndex, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- reservedmarshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities), streamPtrPtr);
- unmarshal_VkDisplayPlaneCapabilitiesKHR(stream, (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));
@@ -15615,13 +15618,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDisplaySurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkDisplaySurfaceCreateInfoKHR));
- deepcopy_VkDisplaySurfaceCreateInfoKHR(pool, pCreateInfo, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkDisplaySurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -15637,12 +15640,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDisplaySurfaceCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -15659,7 +15662,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplaySurfaceCreateInfoKHR(stream, (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);
@@ -15667,7 +15670,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -15717,14 +15720,14 @@
local_pCreateInfos = (VkSwapchainCreateInfoKHR*)pool->alloc(((swapchainCount)) * sizeof(const VkSwapchainCreateInfoKHR));
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
- deepcopy_VkSwapchainCreateInfoKHR(pool, pCreateInfos + i, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
+ deepcopy_VkSwapchainCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfos)
@@ -15746,13 +15749,13 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
- count_VkSwapchainCreateInfoKHR(sFeatureBits, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i), countPtr);
+ count_VkSwapchainCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
if (((swapchainCount)))
{
@@ -15775,7 +15778,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
- reservedmarshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i), streamPtrPtr);
+ 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;
@@ -15784,7 +15787,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
if (((swapchainCount)))
@@ -15839,13 +15842,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkXlibSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXlibSurfaceCreateInfoKHR));
- deepcopy_VkXlibSurfaceCreateInfoKHR(pool, pCreateInfo, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkXlibSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -15861,12 +15864,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkXlibSurfaceCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -15883,7 +15886,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkXlibSurfaceCreateInfoKHR(stream, (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);
@@ -15891,7 +15894,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -15994,13 +15997,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkXcbSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXcbSurfaceCreateInfoKHR));
- deepcopy_VkXcbSurfaceCreateInfoKHR(pool, pCreateInfo, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkXcbSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -16016,12 +16019,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkXcbSurfaceCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -16038,7 +16041,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkXcbSurfaceCreateInfoKHR(stream, (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);
@@ -16046,7 +16049,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -16149,13 +16152,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkWaylandSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWaylandSurfaceCreateInfoKHR));
- deepcopy_VkWaylandSurfaceCreateInfoKHR(pool, pCreateInfo, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkWaylandSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -16171,12 +16174,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkWaylandSurfaceCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -16193,7 +16196,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkWaylandSurfaceCreateInfoKHR(stream, (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);
@@ -16201,7 +16204,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -16298,13 +16301,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkAndroidSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkAndroidSurfaceCreateInfoKHR));
- deepcopy_VkAndroidSurfaceCreateInfoKHR(pool, pCreateInfo, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkAndroidSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -16320,12 +16323,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAndroidSurfaceCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -16342,7 +16345,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAndroidSurfaceCreateInfoKHR(stream, (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);
@@ -16350,7 +16353,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -16395,13 +16398,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkWin32SurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWin32SurfaceCreateInfoKHR));
- deepcopy_VkWin32SurfaceCreateInfoKHR(pool, pCreateInfo, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkWin32SurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -16417,12 +16420,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkWin32SurfaceCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -16439,7 +16442,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkWin32SurfaceCreateInfoKHR(stream, (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);
@@ -16447,7 +16450,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -16540,7 +16543,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceFeatures2(sFeatureBits, (VkPhysicalDeviceFeatures2*)(pFeatures), countPtr);
+ count_VkPhysicalDeviceFeatures2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceFeatures2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures2KHR);
@@ -16554,8 +16557,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures), streamPtrPtr);
- unmarshal_VkPhysicalDeviceFeatures2(stream, (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));
@@ -16586,7 +16589,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceProperties2(sFeatureBits, (VkPhysicalDeviceProperties2*)(pProperties), countPtr);
+ count_VkPhysicalDeviceProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties2*)(pProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties2KHR);
@@ -16600,8 +16603,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceProperties2(stream, (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));
@@ -16637,7 +16640,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkFormat);
- count_VkFormatProperties2(sFeatureBits, (VkFormatProperties2*)(pFormatProperties), countPtr);
+ count_VkFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties2*)(pFormatProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties2KHR);
@@ -16653,8 +16656,8 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkFormat*)&local_format, sizeof(VkFormat));
*streamPtrPtr += sizeof(VkFormat);
- reservedmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties), streamPtrPtr);
- unmarshal_VkFormatProperties2(stream, (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));
@@ -16686,7 +16689,7 @@
if (pImageFormatInfo)
{
local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
- deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
}
if (local_pImageFormatInfo)
{
@@ -16697,8 +16700,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceImageFormatInfo2(sFeatureBits, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), countPtr);
- count_VkImageFormatProperties2(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR);
@@ -16712,9 +16715,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), streamPtrPtr);
- reservedmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties), streamPtrPtr);
- unmarshal_VkImageFormatProperties2(stream, (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));
@@ -16763,7 +16766,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- count_VkQueueFamilyProperties2(sFeatureBits, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), countPtr);
+ count_VkQueueFamilyProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), countPtr);
}
}
}
@@ -16799,7 +16802,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- reservedmarshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
+ reservedmarshal_VkQueueFamilyProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -16826,7 +16829,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
{
- unmarshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ unmarshal_VkQueueFamilyProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
}
}
}
@@ -16866,7 +16869,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceMemoryProperties2(sFeatureBits, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), countPtr);
+ count_VkPhysicalDeviceMemoryProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties2KHR);
@@ -16880,8 +16883,8 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (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));
@@ -16915,7 +16918,7 @@
if (pFormatInfo)
{
local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
- deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
}
if (local_pFormatInfo)
{
@@ -16926,7 +16929,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSparseImageFormatInfo2(sFeatureBits, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), countPtr);
+ count_VkPhysicalDeviceSparseImageFormatInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pPropertyCount)
@@ -16941,7 +16944,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkSparseImageFormatProperties2(sFeatureBits, (VkSparseImageFormatProperties2*)(pProperties + i), countPtr);
+ count_VkSparseImageFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i), countPtr);
}
}
}
@@ -16958,7 +16961,7 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (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);
@@ -16978,7 +16981,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkSparseImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -17005,7 +17008,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+ unmarshal_VkSparseImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i));
}
}
}
@@ -17305,7 +17308,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
{
- count_VkPhysicalDeviceGroupProperties(sFeatureBits, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), countPtr);
+ count_VkPhysicalDeviceGroupProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), countPtr);
}
}
}
@@ -17341,7 +17344,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
{
- reservedmarshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceGroupProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -17368,7 +17371,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
{
- unmarshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ unmarshal_VkPhysicalDeviceGroupProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
}
}
}
@@ -17414,7 +17417,7 @@
if (pExternalBufferInfo)
{
local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
- deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
}
if (local_pExternalBufferInfo)
{
@@ -17426,8 +17429,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalBufferInfo(sFeatureBits, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), countPtr);
- count_VkExternalBufferProperties(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR);
@@ -17441,9 +17444,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), streamPtrPtr);
- reservedmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties), streamPtrPtr);
- unmarshal_VkExternalBufferProperties(stream, (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);
@@ -17480,7 +17483,7 @@
if (pGetWin32HandleInfo)
{
local_pGetWin32HandleInfo = (VkMemoryGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkMemoryGetWin32HandleInfoKHR));
- deepcopy_VkMemoryGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ deepcopy_VkMemoryGetWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
if (local_pGetWin32HandleInfo)
{
@@ -17491,7 +17494,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryGetWin32HandleInfoKHR(sFeatureBits, (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;
@@ -17506,7 +17509,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryGetWin32HandleInfoKHR(stream, (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));
@@ -17547,7 +17550,7 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
*countPtr += sizeof(HANDLE);
- count_VkMemoryWin32HandlePropertiesKHR(sFeatureBits, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties), countPtr);
+ count_VkMemoryWin32HandlePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties), countPtr);
}
uint32_t packetSize_vkGetMemoryWin32HandlePropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryWin32HandlePropertiesKHR);
@@ -17565,8 +17568,8 @@
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*streamPtrPtr, (HANDLE*)&local_handle, sizeof(HANDLE));
*streamPtrPtr += sizeof(HANDLE);
- reservedmarshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties), streamPtrPtr);
- unmarshal_VkMemoryWin32HandlePropertiesKHR(stream, (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));
@@ -17603,7 +17606,7 @@
if (pGetFdInfo)
{
local_pGetFdInfo = (VkMemoryGetFdInfoKHR*)pool->alloc(sizeof(const VkMemoryGetFdInfoKHR));
- deepcopy_VkMemoryGetFdInfoKHR(pool, pGetFdInfo, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+ deepcopy_VkMemoryGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
}
if (local_pGetFdInfo)
{
@@ -17614,7 +17617,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryGetFdInfoKHR(sFeatureBits, (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;
@@ -17629,7 +17632,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryGetFdInfoKHR(stream, (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));
@@ -17670,7 +17673,7 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
*countPtr += sizeof(int);
- count_VkMemoryFdPropertiesKHR(sFeatureBits, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties), countPtr);
+ count_VkMemoryFdPropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties), countPtr);
}
uint32_t packetSize_vkGetMemoryFdPropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryFdPropertiesKHR);
@@ -17688,8 +17691,8 @@
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*streamPtrPtr, (int*)&local_fd, sizeof(int));
*streamPtrPtr += sizeof(int);
- reservedmarshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties), streamPtrPtr);
- unmarshal_VkMemoryFdPropertiesKHR(stream, (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));
@@ -17728,7 +17731,7 @@
if (pExternalSemaphoreInfo)
{
local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
- deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
}
if (local_pExternalSemaphoreInfo)
{
@@ -17739,8 +17742,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalSemaphoreInfo(sFeatureBits, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), countPtr);
- count_VkExternalSemaphoreProperties(sFeatureBits, (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);
@@ -17754,9 +17757,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), streamPtrPtr);
- reservedmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), streamPtrPtr);
- unmarshal_VkExternalSemaphoreProperties(stream, (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));
@@ -17792,7 +17795,7 @@
if (pImportSemaphoreWin32HandleInfo)
{
local_pImportSemaphoreWin32HandleInfo = (VkImportSemaphoreWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreWin32HandleInfoKHR));
- deepcopy_VkImportSemaphoreWin32HandleInfoKHR(pool, pImportSemaphoreWin32HandleInfo, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+ deepcopy_VkImportSemaphoreWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportSemaphoreWin32HandleInfo, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
}
if (local_pImportSemaphoreWin32HandleInfo)
{
@@ -17803,7 +17806,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportSemaphoreWin32HandleInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkImportSemaphoreWin32HandleKHR);
@@ -17817,7 +17820,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportSemaphoreWin32HandleInfoKHR(stream, (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;;
@@ -17848,7 +17851,7 @@
if (pGetWin32HandleInfo)
{
local_pGetWin32HandleInfo = (VkSemaphoreGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetWin32HandleInfoKHR));
- deepcopy_VkSemaphoreGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ deepcopy_VkSemaphoreGetWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
if (local_pGetWin32HandleInfo)
{
@@ -17859,7 +17862,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreGetWin32HandleInfoKHR(sFeatureBits, (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;
@@ -17874,7 +17877,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreGetWin32HandleInfoKHR(stream, (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));
@@ -17909,7 +17912,7 @@
if (pImportSemaphoreFdInfo)
{
local_pImportSemaphoreFdInfo = (VkImportSemaphoreFdInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreFdInfoKHR));
- deepcopy_VkImportSemaphoreFdInfoKHR(pool, pImportSemaphoreFdInfo, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+ deepcopy_VkImportSemaphoreFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportSemaphoreFdInfo, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
}
if (local_pImportSemaphoreFdInfo)
{
@@ -17920,7 +17923,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportSemaphoreFdInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkImportSemaphoreFdKHR);
@@ -17934,7 +17937,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportSemaphoreFdInfoKHR(stream, (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;;
@@ -17965,7 +17968,7 @@
if (pGetFdInfo)
{
local_pGetFdInfo = (VkSemaphoreGetFdInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetFdInfoKHR));
- deepcopy_VkSemaphoreGetFdInfoKHR(pool, pGetFdInfo, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+ deepcopy_VkSemaphoreGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
}
if (local_pGetFdInfo)
{
@@ -17976,7 +17979,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreGetFdInfoKHR(sFeatureBits, (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;
@@ -17991,7 +17994,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreGetFdInfoKHR(stream, (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));
@@ -18040,7 +18043,7 @@
local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
{
- deepcopy_VkWriteDescriptorSet(pool, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
}
}
if (local_pDescriptorWrites)
@@ -18062,7 +18065,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
{
- count_VkWriteDescriptorSet(sFeatureBits, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), countPtr);
+ count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), countPtr);
}
}
uint32_t packetSize_vkCmdPushDescriptorSetKHR = 4 + 4 + count;
@@ -18091,7 +18094,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
{
- reservedmarshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), streamPtrPtr);
+ reservedmarshal_VkWriteDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -18214,13 +18217,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
- deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -18236,12 +18239,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorUpdateTemplateCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -18258,7 +18261,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(stream, (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);
@@ -18266,7 +18269,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -18312,7 +18315,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -18330,7 +18333,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDescriptorUpdateTemplateKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -18356,7 +18359,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
stream->flush();
@@ -18470,13 +18473,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkRenderPassCreateInfo2*)pool->alloc(sizeof(const VkRenderPassCreateInfo2));
- deepcopy_VkRenderPassCreateInfo2(pool, pCreateInfo, (VkRenderPassCreateInfo2*)(local_pCreateInfo));
+ deepcopy_VkRenderPassCreateInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkRenderPassCreateInfo2*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -18492,12 +18495,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassCreateInfo2(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -18514,7 +18517,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRenderPassCreateInfo2(stream, (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);
@@ -18522,7 +18525,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -18564,13 +18567,13 @@
if (pRenderPassBegin)
{
local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
- deepcopy_VkRenderPassBeginInfo(pool, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ 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, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
if (local_pRenderPassBegin)
{
@@ -18585,8 +18588,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassBeginInfo(sFeatureBits, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), countPtr);
- count_VkSubpassBeginInfo(sFeatureBits, (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;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderPass2KHR -= 8;
@@ -18602,8 +18605,8 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), streamPtrPtr);
- reservedmarshal_VkSubpassBeginInfo(stream, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), streamPtrPtr);
+ 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)
{
@@ -18632,13 +18635,13 @@
if (pSubpassBeginInfo)
{
local_pSubpassBeginInfo = (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
- deepcopy_VkSubpassBeginInfo(pool, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
local_pSubpassEndInfo = nullptr;
if (pSubpassEndInfo)
{
local_pSubpassEndInfo = (VkSubpassEndInfo*)pool->alloc(sizeof(const VkSubpassEndInfo));
- deepcopy_VkSubpassEndInfo(pool, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
if (local_pSubpassBeginInfo)
{
@@ -18653,8 +18656,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSubpassBeginInfo(sFeatureBits, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
- count_VkSubpassEndInfo(sFeatureBits, (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;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdNextSubpass2KHR -= 8;
@@ -18670,8 +18673,8 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSubpassBeginInfo(stream, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), streamPtrPtr);
- reservedmarshal_VkSubpassEndInfo(stream, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
+ 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)
{
@@ -18698,7 +18701,7 @@
if (pSubpassEndInfo)
{
local_pSubpassEndInfo = (VkSubpassEndInfo*)pool->alloc(sizeof(const VkSubpassEndInfo));
- deepcopy_VkSubpassEndInfo(pool, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
if (local_pSubpassEndInfo)
{
@@ -18709,7 +18712,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSubpassEndInfo(sFeatureBits, (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
+ count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdEndRenderPass2KHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderPass2KHR -= 8;
@@ -18725,7 +18728,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSubpassEndInfo(stream, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
+ reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -18807,7 +18810,7 @@
if (pExternalFenceInfo)
{
local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
- deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
}
if (local_pExternalFenceInfo)
{
@@ -18818,8 +18821,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalFenceInfo(sFeatureBits, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), countPtr);
- count_VkExternalFenceProperties(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR);
@@ -18833,9 +18836,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), streamPtrPtr);
- reservedmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties), streamPtrPtr);
- unmarshal_VkExternalFenceProperties(stream, (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));
@@ -18870,7 +18873,7 @@
if (pImportFenceWin32HandleInfo)
{
local_pImportFenceWin32HandleInfo = (VkImportFenceWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportFenceWin32HandleInfoKHR));
- deepcopy_VkImportFenceWin32HandleInfoKHR(pool, pImportFenceWin32HandleInfo, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+ deepcopy_VkImportFenceWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportFenceWin32HandleInfo, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
}
if (local_pImportFenceWin32HandleInfo)
{
@@ -18881,7 +18884,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportFenceWin32HandleInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkImportFenceWin32HandleKHR);
@@ -18895,7 +18898,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportFenceWin32HandleInfoKHR(stream, (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;;
@@ -18926,7 +18929,7 @@
if (pGetWin32HandleInfo)
{
local_pGetWin32HandleInfo = (VkFenceGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkFenceGetWin32HandleInfoKHR));
- deepcopy_VkFenceGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ deepcopy_VkFenceGetWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
if (local_pGetWin32HandleInfo)
{
@@ -18937,7 +18940,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkFenceGetWin32HandleInfoKHR(sFeatureBits, (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;
@@ -18952,7 +18955,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkFenceGetWin32HandleInfoKHR(stream, (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));
@@ -18987,7 +18990,7 @@
if (pImportFenceFdInfo)
{
local_pImportFenceFdInfo = (VkImportFenceFdInfoKHR*)pool->alloc(sizeof(const VkImportFenceFdInfoKHR));
- deepcopy_VkImportFenceFdInfoKHR(pool, pImportFenceFdInfo, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+ deepcopy_VkImportFenceFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportFenceFdInfo, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
}
if (local_pImportFenceFdInfo)
{
@@ -18998,7 +19001,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportFenceFdInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkImportFenceFdKHR);
@@ -19012,7 +19015,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportFenceFdInfoKHR(stream, (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;;
@@ -19043,7 +19046,7 @@
if (pGetFdInfo)
{
local_pGetFdInfo = (VkFenceGetFdInfoKHR*)pool->alloc(sizeof(const VkFenceGetFdInfoKHR));
- deepcopy_VkFenceGetFdInfoKHR(pool, pGetFdInfo, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+ deepcopy_VkFenceGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
}
if (local_pGetFdInfo)
{
@@ -19054,7 +19057,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkFenceGetFdInfoKHR(sFeatureBits, (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;
@@ -19069,7 +19072,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkFenceGetFdInfoKHR(stream, (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));
@@ -19124,7 +19127,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
{
- count_VkPerformanceCounterKHR(sFeatureBits, (VkPerformanceCounterKHR*)(pCounters + i), countPtr);
+ count_VkPerformanceCounterKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterKHR*)(pCounters + i), countPtr);
}
}
}
@@ -19136,7 +19139,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
{
- count_VkPerformanceCounterDescriptionKHR(sFeatureBits, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i), countPtr);
+ count_VkPerformanceCounterDescriptionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i), countPtr);
}
}
}
@@ -19174,7 +19177,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
{
- reservedmarshal_VkPerformanceCounterKHR(stream, (VkPerformanceCounterKHR*)(pCounters + i), streamPtrPtr);
+ reservedmarshal_VkPerformanceCounterKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterKHR*)(pCounters + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -19186,7 +19189,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
{
- reservedmarshal_VkPerformanceCounterDescriptionKHR(stream, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i), streamPtrPtr);
+ reservedmarshal_VkPerformanceCounterDescriptionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -19213,7 +19216,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
{
- unmarshal_VkPerformanceCounterKHR(stream, (VkPerformanceCounterKHR*)(pCounters + i));
+ unmarshal_VkPerformanceCounterKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterKHR*)(pCounters + i));
}
}
}
@@ -19240,7 +19243,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
{
- unmarshal_VkPerformanceCounterDescriptionKHR(stream, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i));
+ unmarshal_VkPerformanceCounterDescriptionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i));
}
}
}
@@ -19284,7 +19287,7 @@
if (pPerformanceQueryCreateInfo)
{
local_pPerformanceQueryCreateInfo = (VkQueryPoolPerformanceCreateInfoKHR*)pool->alloc(sizeof(const VkQueryPoolPerformanceCreateInfoKHR));
- deepcopy_VkQueryPoolPerformanceCreateInfoKHR(pool, pPerformanceQueryCreateInfo, (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo));
+ deepcopy_VkQueryPoolPerformanceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPerformanceQueryCreateInfo, (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo));
}
if (local_pPerformanceQueryCreateInfo)
{
@@ -19295,7 +19298,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkQueryPoolPerformanceCreateInfoKHR(sFeatureBits, (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;
@@ -19310,7 +19313,7 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(stream, (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));
@@ -19340,7 +19343,7 @@
if (pInfo)
{
local_pInfo = (VkAcquireProfilingLockInfoKHR*)pool->alloc(sizeof(const VkAcquireProfilingLockInfoKHR));
- deepcopy_VkAcquireProfilingLockInfoKHR(pool, pInfo, (VkAcquireProfilingLockInfoKHR*)(local_pInfo));
+ deepcopy_VkAcquireProfilingLockInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkAcquireProfilingLockInfoKHR*)(local_pInfo));
}
if (local_pInfo)
{
@@ -19351,7 +19354,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAcquireProfilingLockInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireProfilingLockKHR);
@@ -19365,7 +19368,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAcquireProfilingLockInfoKHR(stream, (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;;
@@ -19439,7 +19442,7 @@
if (pSurfaceInfo)
{
local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
- deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
if (local_pSurfaceInfo)
{
@@ -19450,8 +19453,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
- count_VkSurfaceCapabilities2KHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR);
@@ -19465,9 +19468,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), streamPtrPtr);
- reservedmarshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities), streamPtrPtr);
- unmarshal_VkSurfaceCapabilities2KHR(stream, (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));
@@ -19503,7 +19506,7 @@
if (pSurfaceInfo)
{
local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
- deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
if (local_pSurfaceInfo)
{
@@ -19514,7 +19517,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
+ count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pSurfaceFormatCount)
@@ -19529,7 +19532,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
{
- count_VkSurfaceFormat2KHR(sFeatureBits, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i), countPtr);
+ count_VkSurfaceFormat2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i), countPtr);
}
}
}
@@ -19546,7 +19549,7 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (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);
@@ -19566,7 +19569,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
{
- reservedmarshal_VkSurfaceFormat2KHR(stream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i), streamPtrPtr);
+ reservedmarshal_VkSurfaceFormat2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -19593,7 +19596,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
{
- unmarshal_VkSurfaceFormat2KHR(stream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+ unmarshal_VkSurfaceFormat2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
}
}
}
@@ -19655,7 +19658,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkDisplayProperties2KHR(sFeatureBits, (VkDisplayProperties2KHR*)(pProperties + i), countPtr);
+ count_VkDisplayProperties2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayProperties2KHR*)(pProperties + i), countPtr);
}
}
}
@@ -19691,7 +19694,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkDisplayProperties2KHR(stream, (VkDisplayProperties2KHR*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkDisplayProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayProperties2KHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -19718,7 +19721,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkDisplayProperties2KHR(stream, (VkDisplayProperties2KHR*)(pProperties + i));
+ unmarshal_VkDisplayProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayProperties2KHR*)(pProperties + i));
}
}
}
@@ -19776,7 +19779,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkDisplayPlaneProperties2KHR(sFeatureBits, (VkDisplayPlaneProperties2KHR*)(pProperties + i), countPtr);
+ count_VkDisplayPlaneProperties2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneProperties2KHR*)(pProperties + i), countPtr);
}
}
}
@@ -19812,7 +19815,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkDisplayPlaneProperties2KHR(stream, (VkDisplayPlaneProperties2KHR*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkDisplayPlaneProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneProperties2KHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -19839,7 +19842,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkDisplayPlaneProperties2KHR(stream, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+ unmarshal_VkDisplayPlaneProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
}
}
}
@@ -19902,7 +19905,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkDisplayModeProperties2KHR(sFeatureBits, (VkDisplayModeProperties2KHR*)(pProperties + i), countPtr);
+ count_VkDisplayModeProperties2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeProperties2KHR*)(pProperties + i), countPtr);
}
}
}
@@ -19942,7 +19945,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkDisplayModeProperties2KHR(stream, (VkDisplayModeProperties2KHR*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkDisplayModeProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeProperties2KHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -19969,7 +19972,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkDisplayModeProperties2KHR(stream, (VkDisplayModeProperties2KHR*)(pProperties + i));
+ unmarshal_VkDisplayModeProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeProperties2KHR*)(pProperties + i));
}
}
}
@@ -20013,7 +20016,7 @@
if (pDisplayPlaneInfo)
{
local_pDisplayPlaneInfo = (VkDisplayPlaneInfo2KHR*)pool->alloc(sizeof(const VkDisplayPlaneInfo2KHR));
- deepcopy_VkDisplayPlaneInfo2KHR(pool, pDisplayPlaneInfo, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+ deepcopy_VkDisplayPlaneInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayPlaneInfo, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
}
if (local_pDisplayPlaneInfo)
{
@@ -20024,8 +20027,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDisplayPlaneInfo2KHR(sFeatureBits, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo), countPtr);
- count_VkDisplayPlaneCapabilities2KHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDisplayPlaneCapabilities2KHR);
@@ -20039,9 +20042,9 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplayPlaneInfo2KHR(stream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo), streamPtrPtr);
- reservedmarshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities), streamPtrPtr);
- unmarshal_VkDisplayPlaneCapabilities2KHR(stream, (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));
@@ -20084,7 +20087,7 @@
if (pInfo)
{
local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
- deepcopy_VkImageMemoryRequirementsInfo2(pool, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ deepcopy_VkImageMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
}
if (local_pInfo)
{
@@ -20095,8 +20098,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageMemoryRequirementsInfo2(sFeatureBits, (VkImageMemoryRequirementsInfo2*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements2KHR);
@@ -20110,9 +20113,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, (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));
@@ -20144,7 +20147,7 @@
if (pInfo)
{
local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
- deepcopy_VkBufferMemoryRequirementsInfo2(pool, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ deepcopy_VkBufferMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
}
if (local_pInfo)
{
@@ -20155,8 +20158,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferMemoryRequirementsInfo2(sFeatureBits, (VkBufferMemoryRequirementsInfo2*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements2KHR);
@@ -20170,9 +20173,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, (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));
@@ -20205,7 +20208,7 @@
if (pInfo)
{
local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
- deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
}
if (local_pInfo)
{
@@ -20216,7 +20219,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageSparseMemoryRequirementsInfo2(sFeatureBits, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), countPtr);
+ count_VkImageSparseMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pSparseMemoryRequirementCount)
@@ -20231,7 +20234,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- count_VkSparseImageMemoryRequirements2(sFeatureBits, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), countPtr);
+ count_VkSparseImageMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), countPtr);
}
}
}
@@ -20248,7 +20251,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageSparseMemoryRequirementsInfo2(stream, (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);
@@ -20268,7 +20271,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- reservedmarshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
+ reservedmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -20295,7 +20298,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
{
- unmarshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ unmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
}
}
}
@@ -20342,13 +20345,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
- deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -20364,12 +20367,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSamplerYcbcrConversionCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -20386,7 +20389,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSamplerYcbcrConversionCreateInfo(stream, (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);
@@ -20394,7 +20397,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -20439,7 +20442,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -20457,7 +20460,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroySamplerYcbcrConversionKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -20483,7 +20486,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
stream->flush();
@@ -20520,7 +20523,7 @@
local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- deepcopy_VkBindBufferMemoryInfo(pool, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ deepcopy_VkBindBufferMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
}
}
if (local_pBindInfos)
@@ -20538,7 +20541,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- count_VkBindBufferMemoryInfo(sFeatureBits, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), countPtr);
+ count_VkBindBufferMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), countPtr);
}
}
uint32_t packetSize_vkBindBufferMemory2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -20557,7 +20560,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- reservedmarshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), streamPtrPtr);
+ 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));
@@ -20593,7 +20596,7 @@
local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- deepcopy_VkBindImageMemoryInfo(pool, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ deepcopy_VkBindImageMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
}
}
if (local_pBindInfos)
@@ -20611,7 +20614,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- count_VkBindImageMemoryInfo(sFeatureBits, (VkBindImageMemoryInfo*)(local_pBindInfos + i), countPtr);
+ count_VkBindImageMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindImageMemoryInfo*)(local_pBindInfos + i), countPtr);
}
}
uint32_t packetSize_vkBindImageMemory2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -20630,7 +20633,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- reservedmarshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i), streamPtrPtr);
+ 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));
@@ -20666,7 +20669,7 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
- deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
if (local_pCreateInfo)
{
@@ -20677,8 +20680,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), countPtr);
- count_VkDescriptorSetLayoutSupport(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDescriptorSetLayoutSupportKHR);
@@ -20692,9 +20695,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), streamPtrPtr);
- reservedmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport), streamPtrPtr);
- unmarshal_VkDescriptorSetLayoutSupport(stream, (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));
@@ -20966,7 +20969,7 @@
if (pWaitInfo)
{
local_pWaitInfo = (VkSemaphoreWaitInfo*)pool->alloc(sizeof(const VkSemaphoreWaitInfo));
- deepcopy_VkSemaphoreWaitInfo(pool, pWaitInfo, (VkSemaphoreWaitInfo*)(local_pWaitInfo));
+ deepcopy_VkSemaphoreWaitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pWaitInfo, (VkSemaphoreWaitInfo*)(local_pWaitInfo));
}
local_timeout = timeout;
if (local_pWaitInfo)
@@ -20978,7 +20981,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreWaitInfo(sFeatureBits, (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;
@@ -20993,7 +20996,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreWaitInfo(stream, (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;
@@ -21025,7 +21028,7 @@
if (pSignalInfo)
{
local_pSignalInfo = (VkSemaphoreSignalInfo*)pool->alloc(sizeof(const VkSemaphoreSignalInfo));
- deepcopy_VkSemaphoreSignalInfo(pool, pSignalInfo, (VkSemaphoreSignalInfo*)(local_pSignalInfo));
+ deepcopy_VkSemaphoreSignalInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSignalInfo, (VkSemaphoreSignalInfo*)(local_pSignalInfo));
}
if (local_pSignalInfo)
{
@@ -21036,7 +21039,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreSignalInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkSignalSemaphoreKHR);
@@ -21050,7 +21053,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreSignalInfo(stream, (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;;
@@ -21101,7 +21104,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i)
{
- count_VkPhysicalDeviceFragmentShadingRateKHR(sFeatureBits, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i), countPtr);
+ count_VkPhysicalDeviceFragmentShadingRateKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i), countPtr);
}
}
}
@@ -21137,7 +21140,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i)
{
- reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(stream, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -21164,7 +21167,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i)
{
- unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(stream, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i));
+ unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i));
}
}
}
@@ -21209,7 +21212,7 @@
if (pFragmentSize)
{
local_pFragmentSize = (VkExtent2D*)pool->alloc(sizeof(const VkExtent2D));
- deepcopy_VkExtent2D(pool, 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)
@@ -21221,7 +21224,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkExtent2D(sFeatureBits, (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;
@@ -21238,7 +21241,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkExtent2D(stream, (VkExtent2D*)(local_pFragmentSize), streamPtrPtr);
+ 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;;
@@ -21277,7 +21280,7 @@
if (pInfo)
{
local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
}
if (local_pInfo)
{
@@ -21288,7 +21291,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferDeviceAddressKHR);
@@ -21302,7 +21305,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, (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;;
@@ -21332,7 +21335,7 @@
if (pInfo)
{
local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
}
if (local_pInfo)
{
@@ -21343,7 +21346,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferOpaqueCaptureAddressKHR);
@@ -21357,7 +21360,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, (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;;
@@ -21387,7 +21390,7 @@
if (pInfo)
{
local_pInfo = (VkDeviceMemoryOpaqueCaptureAddressInfo*)pool->alloc(sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo));
- deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(pool, pInfo, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
+ deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
}
if (local_pInfo)
{
@@ -21398,7 +21401,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceMemoryOpaqueCaptureAddressInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR);
@@ -21412,7 +21415,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(stream, (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;;
@@ -21445,7 +21448,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -21461,7 +21464,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
@@ -21484,7 +21487,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ 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);
@@ -21523,7 +21526,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -21540,7 +21543,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDeferredOperationKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -21566,7 +21569,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
stream->flush();
++encodeCount;;
@@ -21746,7 +21749,7 @@
if (pPipelineInfo)
{
local_pPipelineInfo = (VkPipelineInfoKHR*)pool->alloc(sizeof(const VkPipelineInfoKHR));
- deepcopy_VkPipelineInfoKHR(pool, pPipelineInfo, (VkPipelineInfoKHR*)(local_pPipelineInfo));
+ deepcopy_VkPipelineInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPipelineInfo, (VkPipelineInfoKHR*)(local_pPipelineInfo));
}
if (local_pPipelineInfo)
{
@@ -21757,7 +21760,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineInfoKHR(sFeatureBits, (VkPipelineInfoKHR*)(local_pPipelineInfo), countPtr);
+ count_VkPipelineInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineInfoKHR*)(local_pPipelineInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pExecutableCount)
@@ -21772,7 +21775,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i)
{
- count_VkPipelineExecutablePropertiesKHR(sFeatureBits, (VkPipelineExecutablePropertiesKHR*)(pProperties + i), countPtr);
+ count_VkPipelineExecutablePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutablePropertiesKHR*)(pProperties + i), countPtr);
}
}
}
@@ -21789,7 +21792,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineInfoKHR(stream, (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);
@@ -21809,7 +21812,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i)
{
- reservedmarshal_VkPipelineExecutablePropertiesKHR(stream, (VkPipelineExecutablePropertiesKHR*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkPipelineExecutablePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutablePropertiesKHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -21836,7 +21839,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i)
{
- unmarshal_VkPipelineExecutablePropertiesKHR(stream, (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
+ unmarshal_VkPipelineExecutablePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
}
}
}
@@ -21881,7 +21884,7 @@
if (pExecutableInfo)
{
local_pExecutableInfo = (VkPipelineExecutableInfoKHR*)pool->alloc(sizeof(const VkPipelineExecutableInfoKHR));
- deepcopy_VkPipelineExecutableInfoKHR(pool, pExecutableInfo, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
+ deepcopy_VkPipelineExecutableInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExecutableInfo, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
}
if (local_pExecutableInfo)
{
@@ -21892,7 +21895,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineExecutableInfoKHR(sFeatureBits, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo), countPtr);
+ count_VkPipelineExecutableInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pStatisticCount)
@@ -21907,7 +21910,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i)
{
- count_VkPipelineExecutableStatisticKHR(sFeatureBits, (VkPipelineExecutableStatisticKHR*)(pStatistics + i), countPtr);
+ count_VkPipelineExecutableStatisticKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableStatisticKHR*)(pStatistics + i), countPtr);
}
}
}
@@ -21924,7 +21927,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineExecutableInfoKHR(stream, (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);
@@ -21944,7 +21947,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i)
{
- reservedmarshal_VkPipelineExecutableStatisticKHR(stream, (VkPipelineExecutableStatisticKHR*)(pStatistics + i), streamPtrPtr);
+ reservedmarshal_VkPipelineExecutableStatisticKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableStatisticKHR*)(pStatistics + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -21971,7 +21974,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i)
{
- unmarshal_VkPipelineExecutableStatisticKHR(stream, (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
+ unmarshal_VkPipelineExecutableStatisticKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
}
}
}
@@ -22016,7 +22019,7 @@
if (pExecutableInfo)
{
local_pExecutableInfo = (VkPipelineExecutableInfoKHR*)pool->alloc(sizeof(const VkPipelineExecutableInfoKHR));
- deepcopy_VkPipelineExecutableInfoKHR(pool, pExecutableInfo, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
+ deepcopy_VkPipelineExecutableInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExecutableInfo, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
}
if (local_pExecutableInfo)
{
@@ -22027,7 +22030,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineExecutableInfoKHR(sFeatureBits, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo), countPtr);
+ count_VkPipelineExecutableInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pInternalRepresentationCount)
@@ -22042,7 +22045,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i)
{
- count_VkPipelineExecutableInternalRepresentationKHR(sFeatureBits, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i), countPtr);
+ count_VkPipelineExecutableInternalRepresentationKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i), countPtr);
}
}
}
@@ -22059,7 +22062,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineExecutableInfoKHR(stream, (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);
@@ -22079,7 +22082,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i)
{
- reservedmarshal_VkPipelineExecutableInternalRepresentationKHR(stream, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i), streamPtrPtr);
+ reservedmarshal_VkPipelineExecutableInternalRepresentationKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -22106,7 +22109,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i)
{
- unmarshal_VkPipelineExecutableInternalRepresentationKHR(stream, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i));
+ unmarshal_VkPipelineExecutableInternalRepresentationKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i));
}
}
}
@@ -22155,7 +22158,7 @@
if (pCopyBufferInfo)
{
local_pCopyBufferInfo = (VkCopyBufferInfo2KHR*)pool->alloc(sizeof(const VkCopyBufferInfo2KHR));
- deepcopy_VkCopyBufferInfo2KHR(pool, pCopyBufferInfo, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo));
+ deepcopy_VkCopyBufferInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyBufferInfo, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo));
}
if (local_pCopyBufferInfo)
{
@@ -22166,7 +22169,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyBufferInfo2KHR(sFeatureBits, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo), countPtr);
+ count_VkCopyBufferInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyBuffer2KHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBuffer2KHR -= 8;
@@ -22182,7 +22185,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyBufferInfo2KHR(stream, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo), streamPtrPtr);
+ reservedmarshal_VkCopyBufferInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -22209,7 +22212,7 @@
if (pCopyImageInfo)
{
local_pCopyImageInfo = (VkCopyImageInfo2KHR*)pool->alloc(sizeof(const VkCopyImageInfo2KHR));
- deepcopy_VkCopyImageInfo2KHR(pool, pCopyImageInfo, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo));
+ deepcopy_VkCopyImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageInfo, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo));
}
if (local_pCopyImageInfo)
{
@@ -22220,7 +22223,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyImageInfo2KHR(sFeatureBits, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo), countPtr);
+ count_VkCopyImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyImage2KHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImage2KHR -= 8;
@@ -22236,7 +22239,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyImageInfo2KHR(stream, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo), streamPtrPtr);
+ reservedmarshal_VkCopyImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -22263,7 +22266,7 @@
if (pCopyBufferToImageInfo)
{
local_pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2KHR*)pool->alloc(sizeof(const VkCopyBufferToImageInfo2KHR));
- deepcopy_VkCopyBufferToImageInfo2KHR(pool, pCopyBufferToImageInfo, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo));
+ deepcopy_VkCopyBufferToImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyBufferToImageInfo, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo));
}
if (local_pCopyBufferToImageInfo)
{
@@ -22274,7 +22277,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyBufferToImageInfo2KHR(sFeatureBits, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo), countPtr);
+ count_VkCopyBufferToImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyBufferToImage2KHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBufferToImage2KHR -= 8;
@@ -22290,7 +22293,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyBufferToImageInfo2KHR(stream, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo), streamPtrPtr);
+ reservedmarshal_VkCopyBufferToImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -22317,7 +22320,7 @@
if (pCopyImageToBufferInfo)
{
local_pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2KHR*)pool->alloc(sizeof(const VkCopyImageToBufferInfo2KHR));
- deepcopy_VkCopyImageToBufferInfo2KHR(pool, pCopyImageToBufferInfo, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo));
+ deepcopy_VkCopyImageToBufferInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToBufferInfo, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo));
}
if (local_pCopyImageToBufferInfo)
{
@@ -22328,7 +22331,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyImageToBufferInfo2KHR(sFeatureBits, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo), countPtr);
+ count_VkCopyImageToBufferInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyImageToBuffer2KHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImageToBuffer2KHR -= 8;
@@ -22344,7 +22347,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyImageToBufferInfo2KHR(stream, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo), streamPtrPtr);
+ reservedmarshal_VkCopyImageToBufferInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -22371,7 +22374,7 @@
if (pBlitImageInfo)
{
local_pBlitImageInfo = (VkBlitImageInfo2KHR*)pool->alloc(sizeof(const VkBlitImageInfo2KHR));
- deepcopy_VkBlitImageInfo2KHR(pool, pBlitImageInfo, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo));
+ deepcopy_VkBlitImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBlitImageInfo, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo));
}
if (local_pBlitImageInfo)
{
@@ -22382,7 +22385,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBlitImageInfo2KHR(sFeatureBits, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo), countPtr);
+ count_VkBlitImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo), countPtr);
}
uint32_t packetSize_vkCmdBlitImage2KHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBlitImage2KHR -= 8;
@@ -22398,7 +22401,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkBlitImageInfo2KHR(stream, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo), streamPtrPtr);
+ reservedmarshal_VkBlitImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -22425,7 +22428,7 @@
if (pResolveImageInfo)
{
local_pResolveImageInfo = (VkResolveImageInfo2KHR*)pool->alloc(sizeof(const VkResolveImageInfo2KHR));
- deepcopy_VkResolveImageInfo2KHR(pool, pResolveImageInfo, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo));
+ deepcopy_VkResolveImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pResolveImageInfo, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo));
}
if (local_pResolveImageInfo)
{
@@ -22436,7 +22439,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkResolveImageInfo2KHR(sFeatureBits, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo), countPtr);
+ count_VkResolveImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo), countPtr);
}
uint32_t packetSize_vkCmdResolveImage2KHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResolveImage2KHR -= 8;
@@ -22452,7 +22455,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkResolveImageInfo2KHR(stream, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo), streamPtrPtr);
+ reservedmarshal_VkResolveImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -22712,13 +22715,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDebugReportCallbackCreateInfoEXT*)pool->alloc(sizeof(const VkDebugReportCallbackCreateInfoEXT));
- deepcopy_VkDebugReportCallbackCreateInfoEXT(pool, pCreateInfo, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+ deepcopy_VkDebugReportCallbackCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -22734,12 +22737,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugReportCallbackCreateInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -22756,7 +22759,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugReportCallbackCreateInfoEXT(stream, (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);
@@ -22764,7 +22767,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -22809,7 +22812,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -22827,7 +22830,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDebugReportCallbackEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -22853,7 +22856,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDebugReportCallbackEXT((VkDebugReportCallbackEXT*)&callback);
stream->flush();
@@ -22994,7 +22997,7 @@
if (pTagInfo)
{
local_pTagInfo = (VkDebugMarkerObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectTagInfoEXT));
- deepcopy_VkDebugMarkerObjectTagInfoEXT(pool, pTagInfo, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+ deepcopy_VkDebugMarkerObjectTagInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTagInfo, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
}
if (local_pTagInfo)
{
@@ -23005,7 +23008,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugMarkerObjectTagInfoEXT(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkDebugMarkerSetObjectTagEXT);
@@ -23019,7 +23022,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugMarkerObjectTagInfoEXT(stream, (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;;
@@ -23049,7 +23052,7 @@
if (pNameInfo)
{
local_pNameInfo = (VkDebugMarkerObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectNameInfoEXT));
- deepcopy_VkDebugMarkerObjectNameInfoEXT(pool, pNameInfo, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+ deepcopy_VkDebugMarkerObjectNameInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pNameInfo, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
}
if (local_pNameInfo)
{
@@ -23060,7 +23063,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugMarkerObjectNameInfoEXT(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkDebugMarkerSetObjectNameEXT);
@@ -23074,7 +23077,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugMarkerObjectNameInfoEXT(stream, (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;;
@@ -23104,7 +23107,7 @@
if (pMarkerInfo)
{
local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
- deepcopy_VkDebugMarkerMarkerInfoEXT(pool, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ deepcopy_VkDebugMarkerMarkerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
}
if (local_pMarkerInfo)
{
@@ -23115,7 +23118,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugMarkerMarkerInfoEXT(sFeatureBits, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), countPtr);
+ count_VkDebugMarkerMarkerInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), countPtr);
}
uint32_t packetSize_vkCmdDebugMarkerBeginEXT = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDebugMarkerBeginEXT -= 8;
@@ -23131,7 +23134,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), streamPtrPtr);
+ reservedmarshal_VkDebugMarkerMarkerInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -23198,7 +23201,7 @@
if (pMarkerInfo)
{
local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
- deepcopy_VkDebugMarkerMarkerInfoEXT(pool, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ deepcopy_VkDebugMarkerMarkerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
}
if (local_pMarkerInfo)
{
@@ -23209,7 +23212,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugMarkerMarkerInfoEXT(sFeatureBits, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), countPtr);
+ count_VkDebugMarkerMarkerInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), countPtr);
}
uint32_t packetSize_vkCmdDebugMarkerInsertEXT = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDebugMarkerInsertEXT -= 8;
@@ -23225,7 +23228,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), streamPtrPtr);
+ reservedmarshal_VkDebugMarkerMarkerInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -23770,7 +23773,7 @@
if (pInfo)
{
local_pInfo = (VkImageViewHandleInfoNVX*)pool->alloc(sizeof(const VkImageViewHandleInfoNVX));
- deepcopy_VkImageViewHandleInfoNVX(pool, pInfo, (VkImageViewHandleInfoNVX*)(local_pInfo));
+ deepcopy_VkImageViewHandleInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageViewHandleInfoNVX*)(local_pInfo));
}
if (local_pInfo)
{
@@ -23781,7 +23784,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageViewHandleInfoNVX(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageViewHandleNVX);
@@ -23795,7 +23798,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageViewHandleInfoNVX(stream, (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;;
@@ -23830,7 +23833,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkImageViewAddressPropertiesNVX(sFeatureBits, (VkImageViewAddressPropertiesNVX*)(pProperties), countPtr);
+ count_VkImageViewAddressPropertiesNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewAddressPropertiesNVX*)(pProperties), countPtr);
}
uint32_t packetSize_vkGetImageViewAddressNVX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageViewAddressNVX);
@@ -23848,8 +23851,8 @@
*&cgen_var_1 = get_host_u64_VkImageView((*&local_imageView));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageViewAddressPropertiesNVX(stream, (VkImageViewAddressPropertiesNVX*)(pProperties), streamPtrPtr);
- unmarshal_VkImageViewAddressPropertiesNVX(stream, (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));
@@ -24189,13 +24192,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkStreamDescriptorSurfaceCreateInfoGGP*)pool->alloc(sizeof(const VkStreamDescriptorSurfaceCreateInfoGGP));
- deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(pool, pCreateInfo, (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo));
+ deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -24211,12 +24214,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkStreamDescriptorSurfaceCreateInfoGGP(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -24233,7 +24236,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(stream, (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);
@@ -24241,7 +24244,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -24311,7 +24314,7 @@
*countPtr += sizeof(VkImageUsageFlags);
*countPtr += sizeof(VkImageCreateFlags);
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
- count_VkExternalImageFormatPropertiesNV(sFeatureBits, (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);
@@ -24337,8 +24340,8 @@
*streamPtrPtr += sizeof(VkImageCreateFlags);
memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
- reservedmarshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties), streamPtrPtr);
- unmarshal_VkExternalImageFormatPropertiesNV(stream, (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));
@@ -24447,13 +24450,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkViSurfaceCreateInfoNN*)pool->alloc(sizeof(const VkViSurfaceCreateInfoNN));
- deepcopy_VkViSurfaceCreateInfoNN(pool, pCreateInfo, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+ deepcopy_VkViSurfaceCreateInfoNN(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -24469,12 +24472,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkViSurfaceCreateInfoNN(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -24491,7 +24494,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkViSurfaceCreateInfoNN(stream, (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);
@@ -24499,7 +24502,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -24549,7 +24552,7 @@
if (pConditionalRenderingBegin)
{
local_pConditionalRenderingBegin = (VkConditionalRenderingBeginInfoEXT*)pool->alloc(sizeof(const VkConditionalRenderingBeginInfoEXT));
- deepcopy_VkConditionalRenderingBeginInfoEXT(pool, pConditionalRenderingBegin, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+ deepcopy_VkConditionalRenderingBeginInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pConditionalRenderingBegin, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
}
if (local_pConditionalRenderingBegin)
{
@@ -24560,7 +24563,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkConditionalRenderingBeginInfoEXT(sFeatureBits, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin), countPtr);
+ count_VkConditionalRenderingBeginInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin), countPtr);
}
uint32_t packetSize_vkCmdBeginConditionalRenderingEXT = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginConditionalRenderingEXT -= 8;
@@ -24576,7 +24579,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkConditionalRenderingBeginInfoEXT(stream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin), streamPtrPtr);
+ reservedmarshal_VkConditionalRenderingBeginInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -24653,7 +24656,7 @@
local_pViewportWScalings = (VkViewportWScalingNV*)pool->alloc(((viewportCount)) * sizeof(const VkViewportWScalingNV));
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- deepcopy_VkViewportWScalingNV(pool, pViewportWScalings + i, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+ deepcopy_VkViewportWScalingNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewportWScalings + i, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
}
}
if (local_pViewportWScalings)
@@ -24672,7 +24675,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- count_VkViewportWScalingNV(sFeatureBits, (VkViewportWScalingNV*)(local_pViewportWScalings + i), countPtr);
+ count_VkViewportWScalingNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewportWScalingNV*)(local_pViewportWScalings + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetViewportWScalingNV = 4 + 4 + count;
@@ -24695,7 +24698,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- reservedmarshal_VkViewportWScalingNV(stream, (VkViewportWScalingNV*)(local_pViewportWScalings + i), streamPtrPtr);
+ reservedmarshal_VkViewportWScalingNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewportWScalingNV*)(local_pViewportWScalings + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -24903,7 +24906,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkSurfaceCapabilities2EXT(sFeatureBits, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities), countPtr);
+ count_VkSurfaceCapabilities2EXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT);
@@ -24921,8 +24924,8 @@
*&cgen_var_1 = get_host_u64_VkSurfaceKHR((*&local_surface));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities), streamPtrPtr);
- unmarshal_VkSurfaceCapabilities2EXT(stream, (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));
@@ -24961,7 +24964,7 @@
if (pDisplayPowerInfo)
{
local_pDisplayPowerInfo = (VkDisplayPowerInfoEXT*)pool->alloc(sizeof(const VkDisplayPowerInfoEXT));
- deepcopy_VkDisplayPowerInfoEXT(pool, pDisplayPowerInfo, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+ deepcopy_VkDisplayPowerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayPowerInfo, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
}
if (local_pDisplayPowerInfo)
{
@@ -24974,7 +24977,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkDisplayPowerInfoEXT(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkDisplayPowerControlEXT);
@@ -24992,7 +24995,7 @@
*&cgen_var_1 = get_host_u64_VkDisplayKHR((*&local_display));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplayPowerInfoEXT(stream, (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;;
@@ -25025,13 +25028,13 @@
if (pDeviceEventInfo)
{
local_pDeviceEventInfo = (VkDeviceEventInfoEXT*)pool->alloc(sizeof(const VkDeviceEventInfoEXT));
- deepcopy_VkDeviceEventInfoEXT(pool, pDeviceEventInfo, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+ deepcopy_VkDeviceEventInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDeviceEventInfo, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pDeviceEventInfo)
@@ -25047,12 +25050,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceEventInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -25069,7 +25072,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceEventInfoEXT(stream, (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);
@@ -25077,7 +25080,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -25123,13 +25126,13 @@
if (pDisplayEventInfo)
{
local_pDisplayEventInfo = (VkDisplayEventInfoEXT*)pool->alloc(sizeof(const VkDisplayEventInfoEXT));
- deepcopy_VkDisplayEventInfoEXT(pool, pDisplayEventInfo, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+ deepcopy_VkDisplayEventInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayEventInfo, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pDisplayEventInfo)
@@ -25147,12 +25150,12 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkDisplayEventInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_2;
*countPtr += 8;
@@ -25173,7 +25176,7 @@
*&cgen_var_1 = get_host_u64_VkDisplayKHR((*&local_display));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplayEventInfoEXT(stream, (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);
@@ -25181,7 +25184,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_3;
@@ -25289,7 +25292,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkRefreshCycleDurationGOOGLE(sFeatureBits, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties), countPtr);
+ count_VkRefreshCycleDurationGOOGLE(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties), countPtr);
}
uint32_t packetSize_vkGetRefreshCycleDurationGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRefreshCycleDurationGOOGLE);
@@ -25307,8 +25310,8 @@
*&cgen_var_1 = get_host_u64_VkSwapchainKHR((*&local_swapchain));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties), streamPtrPtr);
- unmarshal_VkRefreshCycleDurationGOOGLE(stream, (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));
@@ -25362,7 +25365,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
{
- count_VkPastPresentationTimingGOOGLE(sFeatureBits, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i), countPtr);
+ count_VkPastPresentationTimingGOOGLE(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i), countPtr);
}
}
}
@@ -25402,7 +25405,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
{
- reservedmarshal_VkPastPresentationTimingGOOGLE(stream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i), streamPtrPtr);
+ reservedmarshal_VkPastPresentationTimingGOOGLE(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -25429,7 +25432,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
{
- unmarshal_VkPastPresentationTimingGOOGLE(stream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+ unmarshal_VkPastPresentationTimingGOOGLE(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
}
}
}
@@ -25492,7 +25495,7 @@
local_pDiscardRectangles = (VkRect2D*)pool->alloc(((discardRectangleCount)) * sizeof(const VkRect2D));
for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
{
- deepcopy_VkRect2D(pool, pDiscardRectangles + i, (VkRect2D*)(local_pDiscardRectangles + i));
+ deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDiscardRectangles + i, (VkRect2D*)(local_pDiscardRectangles + i));
}
}
if (local_pDiscardRectangles)
@@ -25511,7 +25514,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
{
- count_VkRect2D(sFeatureBits, (VkRect2D*)(local_pDiscardRectangles + i), countPtr);
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pDiscardRectangles + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetDiscardRectangleEXT = 4 + 4 + count;
@@ -25534,7 +25537,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
{
- reservedmarshal_VkRect2D(stream, (VkRect2D*)(local_pDiscardRectangles + i), streamPtrPtr);
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pDiscardRectangles + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -25579,7 +25582,7 @@
local_pMetadata = (VkHdrMetadataEXT*)pool->alloc(((swapchainCount)) * sizeof(const VkHdrMetadataEXT));
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
- deepcopy_VkHdrMetadataEXT(pool, pMetadata + i, (VkHdrMetadataEXT*)(local_pMetadata + i));
+ deepcopy_VkHdrMetadataEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMetadata + i, (VkHdrMetadataEXT*)(local_pMetadata + i));
}
}
if (local_pMetadata)
@@ -25601,7 +25604,7 @@
}
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
- count_VkHdrMetadataEXT(sFeatureBits, (VkHdrMetadataEXT*)(local_pMetadata + i), countPtr);
+ count_VkHdrMetadataEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkHdrMetadataEXT*)(local_pMetadata + i), countPtr);
}
}
uint32_t packetSize_vkSetHdrMetadataEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -25630,7 +25633,7 @@
}
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
- reservedmarshal_VkHdrMetadataEXT(stream, (VkHdrMetadataEXT*)(local_pMetadata + i), streamPtrPtr);
+ reservedmarshal_VkHdrMetadataEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkHdrMetadataEXT*)(local_pMetadata + i), streamPtrPtr);
}
stream->flush();
++encodeCount;;
@@ -25664,13 +25667,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkIOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkIOSSurfaceCreateInfoMVK));
- deepcopy_VkIOSSurfaceCreateInfoMVK(pool, pCreateInfo, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ deepcopy_VkIOSSurfaceCreateInfoMVK(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -25686,12 +25689,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkIOSSurfaceCreateInfoMVK(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -25708,7 +25711,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkIOSSurfaceCreateInfoMVK(stream, (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);
@@ -25716,7 +25719,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -25761,13 +25764,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkMacOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkMacOSSurfaceCreateInfoMVK));
- deepcopy_VkMacOSSurfaceCreateInfoMVK(pool, pCreateInfo, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ deepcopy_VkMacOSSurfaceCreateInfoMVK(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -25783,12 +25786,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMacOSSurfaceCreateInfoMVK(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -25805,7 +25808,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMacOSSurfaceCreateInfoMVK(stream, (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);
@@ -25813,7 +25816,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -26125,7 +26128,7 @@
if (pNameInfo)
{
local_pNameInfo = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectNameInfoEXT));
- deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, pNameInfo, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+ deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pNameInfo, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
}
if (local_pNameInfo)
{
@@ -26136,7 +26139,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsObjectNameInfoEXT(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkSetDebugUtilsObjectNameEXT);
@@ -26150,7 +26153,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsObjectNameInfoEXT(stream, (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;;
@@ -26180,7 +26183,7 @@
if (pTagInfo)
{
local_pTagInfo = (VkDebugUtilsObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectTagInfoEXT));
- deepcopy_VkDebugUtilsObjectTagInfoEXT(pool, pTagInfo, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+ deepcopy_VkDebugUtilsObjectTagInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTagInfo, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
}
if (local_pTagInfo)
{
@@ -26191,7 +26194,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsObjectTagInfoEXT(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkSetDebugUtilsObjectTagEXT);
@@ -26205,7 +26208,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsObjectTagInfoEXT(stream, (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;;
@@ -26235,7 +26238,7 @@
if (pLabelInfo)
{
local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
if (local_pLabelInfo)
{
@@ -26246,7 +26249,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsLabelEXT(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueBeginDebugUtilsLabelEXT);
@@ -26260,7 +26263,7 @@
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsLabelEXT(stream, (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)
@@ -26327,7 +26330,7 @@
if (pLabelInfo)
{
local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
if (local_pLabelInfo)
{
@@ -26338,7 +26341,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsLabelEXT(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueInsertDebugUtilsLabelEXT);
@@ -26352,7 +26355,7 @@
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsLabelEXT(stream, (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)
@@ -26380,7 +26383,7 @@
if (pLabelInfo)
{
local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
if (local_pLabelInfo)
{
@@ -26391,7 +26394,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsLabelEXT(sFeatureBits, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
+ count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginDebugUtilsLabelEXT = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginDebugUtilsLabelEXT -= 8;
@@ -26407,7 +26410,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
+ reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -26474,7 +26477,7 @@
if (pLabelInfo)
{
local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
if (local_pLabelInfo)
{
@@ -26485,7 +26488,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsLabelEXT(sFeatureBits, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
+ count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
}
uint32_t packetSize_vkCmdInsertDebugUtilsLabelEXT = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdInsertDebugUtilsLabelEXT -= 8;
@@ -26501,7 +26504,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
+ reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -26531,13 +26534,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDebugUtilsMessengerCreateInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCreateInfoEXT));
- deepcopy_VkDebugUtilsMessengerCreateInfoEXT(pool, pCreateInfo, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+ deepcopy_VkDebugUtilsMessengerCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -26553,12 +26556,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsMessengerCreateInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -26575,7 +26578,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(stream, (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);
@@ -26583,7 +26586,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -26628,7 +26631,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -26646,7 +26649,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDebugUtilsMessengerEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -26672,7 +26675,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDebugUtilsMessengerEXT((VkDebugUtilsMessengerEXT*)&messenger);
stream->flush();
@@ -26708,7 +26711,7 @@
if (pCallbackData)
{
local_pCallbackData = (VkDebugUtilsMessengerCallbackDataEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCallbackDataEXT));
- deepcopy_VkDebugUtilsMessengerCallbackDataEXT(pool, pCallbackData, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+ deepcopy_VkDebugUtilsMessengerCallbackDataEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallbackData, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
}
if (local_pCallbackData)
{
@@ -26721,7 +26724,7 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT);
*countPtr += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
- count_VkDebugUtilsMessengerCallbackDataEXT(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkSubmitDebugUtilsMessageEXT);
@@ -26739,7 +26742,7 @@
*streamPtrPtr += sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT);
memcpy(*streamPtrPtr, (VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
*streamPtrPtr += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
- reservedmarshal_VkDebugUtilsMessengerCallbackDataEXT(stream, (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)
@@ -26774,7 +26777,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(AHardwareBuffer);
- count_VkAndroidHardwareBufferPropertiesANDROID(sFeatureBits, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties), countPtr);
+ count_VkAndroidHardwareBufferPropertiesANDROID(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties), countPtr);
}
uint32_t packetSize_vkGetAndroidHardwareBufferPropertiesANDROID = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAndroidHardwareBufferPropertiesANDROID);
@@ -26790,8 +26793,8 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
*streamPtrPtr += sizeof(AHardwareBuffer);
- reservedmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties), streamPtrPtr);
- unmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (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));
@@ -26826,7 +26829,7 @@
if (pInfo)
{
local_pInfo = (VkMemoryGetAndroidHardwareBufferInfoANDROID*)pool->alloc(sizeof(const VkMemoryGetAndroidHardwareBufferInfoANDROID));
- deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(pool, pInfo, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+ deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
}
if (local_pInfo)
{
@@ -26837,7 +26840,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryGetAndroidHardwareBufferInfoANDROID(sFeatureBits, (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;
@@ -26852,7 +26855,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(stream, (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*));
@@ -26899,7 +26902,7 @@
if (pSampleLocationsInfo)
{
local_pSampleLocationsInfo = (VkSampleLocationsInfoEXT*)pool->alloc(sizeof(const VkSampleLocationsInfoEXT));
- deepcopy_VkSampleLocationsInfoEXT(pool, pSampleLocationsInfo, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+ deepcopy_VkSampleLocationsInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSampleLocationsInfo, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
}
if (local_pSampleLocationsInfo)
{
@@ -26910,7 +26913,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSampleLocationsInfoEXT(sFeatureBits, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo), countPtr);
+ count_VkSampleLocationsInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo), countPtr);
}
uint32_t packetSize_vkCmdSetSampleLocationsEXT = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetSampleLocationsEXT -= 8;
@@ -26926,7 +26929,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSampleLocationsInfoEXT(stream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo), streamPtrPtr);
+ reservedmarshal_VkSampleLocationsInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -26957,7 +26960,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkSampleCountFlagBits);
- count_VkMultisamplePropertiesEXT(sFeatureBits, (VkMultisamplePropertiesEXT*)(pMultisampleProperties), countPtr);
+ count_VkMultisamplePropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultisamplePropertiesEXT*)(pMultisampleProperties), countPtr);
}
uint32_t packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT);
@@ -26973,8 +26976,8 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
*streamPtrPtr += sizeof(VkSampleCountFlagBits);
- reservedmarshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties), streamPtrPtr);
- unmarshal_VkMultisamplePropertiesEXT(stream, (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));
@@ -27024,7 +27027,7 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkImageDrmFormatModifierPropertiesEXT(sFeatureBits, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties), countPtr);
+ count_VkImageDrmFormatModifierPropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties), countPtr);
}
uint32_t packetSize_vkGetImageDrmFormatModifierPropertiesEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageDrmFormatModifierPropertiesEXT);
@@ -27042,8 +27045,8 @@
*&cgen_var_1 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageDrmFormatModifierPropertiesEXT(stream, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties), streamPtrPtr);
- unmarshal_VkImageDrmFormatModifierPropertiesEXT(stream, (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));
@@ -27082,13 +27085,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkValidationCacheCreateInfoEXT*)pool->alloc(sizeof(const VkValidationCacheCreateInfoEXT));
- deepcopy_VkValidationCacheCreateInfoEXT(pool, pCreateInfo, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+ deepcopy_VkValidationCacheCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -27104,12 +27107,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkValidationCacheCreateInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -27126,7 +27129,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkValidationCacheCreateInfoEXT(stream, (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);
@@ -27134,7 +27137,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -27179,7 +27182,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -27197,7 +27200,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyValidationCacheEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -27223,7 +27226,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&validationCache);
stream->flush();
@@ -27507,7 +27510,7 @@
local_pShadingRatePalettes = (VkShadingRatePaletteNV*)pool->alloc(((viewportCount)) * sizeof(const VkShadingRatePaletteNV));
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- deepcopy_VkShadingRatePaletteNV(pool, pShadingRatePalettes + i, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i));
+ deepcopy_VkShadingRatePaletteNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pShadingRatePalettes + i, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i));
}
}
if (local_pShadingRatePalettes)
@@ -27526,7 +27529,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- count_VkShadingRatePaletteNV(sFeatureBits, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i), countPtr);
+ count_VkShadingRatePaletteNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetViewportShadingRatePaletteNV = 4 + 4 + count;
@@ -27549,7 +27552,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- reservedmarshal_VkShadingRatePaletteNV(stream, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i), streamPtrPtr);
+ reservedmarshal_VkShadingRatePaletteNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -27585,7 +27588,7 @@
local_pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)pool->alloc(((customSampleOrderCount)) * sizeof(const VkCoarseSampleOrderCustomNV));
for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
{
- deepcopy_VkCoarseSampleOrderCustomNV(pool, pCustomSampleOrders + i, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i));
+ deepcopy_VkCoarseSampleOrderCustomNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCustomSampleOrders + i, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i));
}
}
if (local_pCustomSampleOrders)
@@ -27604,7 +27607,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
{
- count_VkCoarseSampleOrderCustomNV(sFeatureBits, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i), countPtr);
+ count_VkCoarseSampleOrderCustomNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetCoarseSampleOrderNV = 4 + 4 + count;
@@ -27627,7 +27630,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
{
- reservedmarshal_VkCoarseSampleOrderCustomNV(stream, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i), streamPtrPtr);
+ reservedmarshal_VkCoarseSampleOrderCustomNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -27660,13 +27663,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkAccelerationStructureCreateInfoNV*)pool->alloc(sizeof(const VkAccelerationStructureCreateInfoNV));
- deepcopy_VkAccelerationStructureCreateInfoNV(pool, pCreateInfo, (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo));
+ deepcopy_VkAccelerationStructureCreateInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -27682,12 +27685,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureCreateInfoNV(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -27704,7 +27707,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureCreateInfoNV(stream, (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);
@@ -27712,7 +27715,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -27757,7 +27760,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -27775,7 +27778,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyAccelerationStructureNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -27801,7 +27804,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkAccelerationStructureNV((VkAccelerationStructureNV*)&accelerationStructure);
stream->flush();
@@ -27832,7 +27835,7 @@
if (pInfo)
{
local_pInfo = (VkAccelerationStructureMemoryRequirementsInfoNV*)pool->alloc(sizeof(const VkAccelerationStructureMemoryRequirementsInfoNV));
- deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(pool, pInfo, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo));
+ deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo));
}
if (local_pInfo)
{
@@ -27843,8 +27846,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureMemoryRequirementsInfoNV(sFeatureBits, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2KHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAccelerationStructureMemoryRequirementsNV);
@@ -27858,9 +27861,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(stream, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2KHR(stream, (VkMemoryRequirements2KHR*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2KHR(stream, (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));
@@ -27896,7 +27899,7 @@
local_pBindInfos = (VkBindAccelerationStructureMemoryInfoNV*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindAccelerationStructureMemoryInfoNV));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- deepcopy_VkBindAccelerationStructureMemoryInfoNV(pool, pBindInfos + i, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i));
+ deepcopy_VkBindAccelerationStructureMemoryInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i));
}
}
if (local_pBindInfos)
@@ -27914,7 +27917,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- count_VkBindAccelerationStructureMemoryInfoNV(sFeatureBits, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i), countPtr);
+ count_VkBindAccelerationStructureMemoryInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i), countPtr);
}
}
uint32_t packetSize_vkBindAccelerationStructureMemoryNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -27933,7 +27936,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- reservedmarshal_VkBindAccelerationStructureMemoryInfoNV(stream, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i), streamPtrPtr);
+ 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));
@@ -27978,7 +27981,7 @@
if (pInfo)
{
local_pInfo = (VkAccelerationStructureInfoNV*)pool->alloc(sizeof(const VkAccelerationStructureInfoNV));
- deepcopy_VkAccelerationStructureInfoNV(pool, pInfo, (VkAccelerationStructureInfoNV*)(local_pInfo));
+ deepcopy_VkAccelerationStructureInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkAccelerationStructureInfoNV*)(local_pInfo));
}
local_instanceData = instanceData;
local_instanceOffset = instanceOffset;
@@ -27996,7 +27999,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureInfoNV(sFeatureBits, (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);
@@ -28023,7 +28026,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkAccelerationStructureInfoNV(stream, (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);
@@ -28283,14 +28286,14 @@
local_pCreateInfos = (VkRayTracingPipelineCreateInfoNV*)pool->alloc(((createInfoCount)) * sizeof(const VkRayTracingPipelineCreateInfoNV));
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- deepcopy_VkRayTracingPipelineCreateInfoNV(pool, pCreateInfos + i, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i));
+ deepcopy_VkRayTracingPipelineCreateInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfos)
@@ -28314,13 +28317,13 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- count_VkRayTracingPipelineCreateInfoNV(sFeatureBits, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i), countPtr);
+ count_VkRayTracingPipelineCreateInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
if (((createInfoCount)))
{
@@ -28347,7 +28350,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- reservedmarshal_VkRayTracingPipelineCreateInfoNV(stream, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i), streamPtrPtr);
+ 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;
@@ -28356,7 +28359,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
if (((createInfoCount)))
@@ -28784,7 +28787,7 @@
{
*countPtr += sizeof(uint8_t);
}
- count_VkMemoryHostPointerPropertiesEXT(sFeatureBits, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties), countPtr);
+ count_VkMemoryHostPointerPropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties), countPtr);
}
uint32_t packetSize_vkGetMemoryHostPointerPropertiesEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryHostPointerPropertiesEXT);
@@ -28810,8 +28813,8 @@
memcpy(*streamPtrPtr, (void*)local_pHostPointer, sizeof(uint8_t));
*streamPtrPtr += sizeof(uint8_t);
}
- reservedmarshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties), streamPtrPtr);
- unmarshal_VkMemoryHostPointerPropertiesEXT(stream, (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));
@@ -29025,7 +29028,7 @@
local_pTimestampInfos = (VkCalibratedTimestampInfoEXT*)pool->alloc(((timestampCount)) * sizeof(const VkCalibratedTimestampInfoEXT));
for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i)
{
- deepcopy_VkCalibratedTimestampInfoEXT(pool, pTimestampInfos + i, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i));
+ deepcopy_VkCalibratedTimestampInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTimestampInfos + i, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i));
}
}
if (local_pTimestampInfos)
@@ -29043,7 +29046,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i)
{
- count_VkCalibratedTimestampInfoEXT(sFeatureBits, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i), countPtr);
+ count_VkCalibratedTimestampInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i), countPtr);
}
*countPtr += ((timestampCount)) * sizeof(uint64_t);
*countPtr += sizeof(uint64_t);
@@ -29064,7 +29067,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i)
{
- reservedmarshal_VkCalibratedTimestampInfoEXT(stream, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i), streamPtrPtr);
+ 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);
@@ -29332,7 +29335,7 @@
local_pExclusiveScissors = (VkRect2D*)pool->alloc(((exclusiveScissorCount)) * sizeof(const VkRect2D));
for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
{
- deepcopy_VkRect2D(pool, pExclusiveScissors + i, (VkRect2D*)(local_pExclusiveScissors + i));
+ deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExclusiveScissors + i, (VkRect2D*)(local_pExclusiveScissors + i));
}
}
if (local_pExclusiveScissors)
@@ -29351,7 +29354,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
{
- count_VkRect2D(sFeatureBits, (VkRect2D*)(local_pExclusiveScissors + i), countPtr);
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pExclusiveScissors + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetExclusiveScissorNV = 4 + 4 + count;
@@ -29374,7 +29377,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
{
- reservedmarshal_VkRect2D(stream, (VkRect2D*)(local_pExclusiveScissors + i), streamPtrPtr);
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pExclusiveScissors + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -29479,7 +29482,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
{
- count_VkCheckpointDataNV(sFeatureBits, (VkCheckpointDataNV*)(pCheckpointData + i), countPtr);
+ count_VkCheckpointDataNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointDataNV*)(pCheckpointData + i), countPtr);
}
}
}
@@ -29515,7 +29518,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
{
- reservedmarshal_VkCheckpointDataNV(stream, (VkCheckpointDataNV*)(pCheckpointData + i), streamPtrPtr);
+ reservedmarshal_VkCheckpointDataNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointDataNV*)(pCheckpointData + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -29542,7 +29545,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
{
- unmarshal_VkCheckpointDataNV(stream, (VkCheckpointDataNV*)(pCheckpointData + i));
+ unmarshal_VkCheckpointDataNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointDataNV*)(pCheckpointData + i));
}
}
}
@@ -29586,7 +29589,7 @@
if (pInitializeInfo)
{
local_pInitializeInfo = (VkInitializePerformanceApiInfoINTEL*)pool->alloc(sizeof(const VkInitializePerformanceApiInfoINTEL));
- deepcopy_VkInitializePerformanceApiInfoINTEL(pool, pInitializeInfo, (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo));
+ deepcopy_VkInitializePerformanceApiInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInitializeInfo, (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo));
}
if (local_pInitializeInfo)
{
@@ -29597,7 +29600,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkInitializePerformanceApiInfoINTEL(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkInitializePerformanceApiINTEL);
@@ -29611,7 +29614,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkInitializePerformanceApiInfoINTEL(stream, (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;;
@@ -29680,7 +29683,7 @@
if (pMarkerInfo)
{
local_pMarkerInfo = (VkPerformanceMarkerInfoINTEL*)pool->alloc(sizeof(const VkPerformanceMarkerInfoINTEL));
- deepcopy_VkPerformanceMarkerInfoINTEL(pool, pMarkerInfo, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo));
+ deepcopy_VkPerformanceMarkerInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo));
}
if (local_pMarkerInfo)
{
@@ -29691,7 +29694,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPerformanceMarkerInfoINTEL(sFeatureBits, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo), countPtr);
+ count_VkPerformanceMarkerInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo), countPtr);
}
uint32_t packetSize_vkCmdSetPerformanceMarkerINTEL = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPerformanceMarkerINTEL -= 8;
@@ -29707,7 +29710,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkPerformanceMarkerInfoINTEL(stream, (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;;
@@ -29737,7 +29740,7 @@
if (pMarkerInfo)
{
local_pMarkerInfo = (VkPerformanceStreamMarkerInfoINTEL*)pool->alloc(sizeof(const VkPerformanceStreamMarkerInfoINTEL));
- deepcopy_VkPerformanceStreamMarkerInfoINTEL(pool, pMarkerInfo, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo));
+ deepcopy_VkPerformanceStreamMarkerInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo));
}
if (local_pMarkerInfo)
{
@@ -29748,7 +29751,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPerformanceStreamMarkerInfoINTEL(sFeatureBits, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo), countPtr);
+ count_VkPerformanceStreamMarkerInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo), countPtr);
}
uint32_t packetSize_vkCmdSetPerformanceStreamMarkerINTEL = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPerformanceStreamMarkerINTEL -= 8;
@@ -29764,7 +29767,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkPerformanceStreamMarkerInfoINTEL(stream, (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;;
@@ -29794,7 +29797,7 @@
if (pOverrideInfo)
{
local_pOverrideInfo = (VkPerformanceOverrideInfoINTEL*)pool->alloc(sizeof(const VkPerformanceOverrideInfoINTEL));
- deepcopy_VkPerformanceOverrideInfoINTEL(pool, pOverrideInfo, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo));
+ deepcopy_VkPerformanceOverrideInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pOverrideInfo, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo));
}
if (local_pOverrideInfo)
{
@@ -29805,7 +29808,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPerformanceOverrideInfoINTEL(sFeatureBits, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo), countPtr);
+ count_VkPerformanceOverrideInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo), countPtr);
}
uint32_t packetSize_vkCmdSetPerformanceOverrideINTEL = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPerformanceOverrideINTEL -= 8;
@@ -29821,7 +29824,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkPerformanceOverrideInfoINTEL(stream, (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;;
@@ -29852,7 +29855,7 @@
if (pAcquireInfo)
{
local_pAcquireInfo = (VkPerformanceConfigurationAcquireInfoINTEL*)pool->alloc(sizeof(const VkPerformanceConfigurationAcquireInfoINTEL));
- deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(pool, pAcquireInfo, (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo));
+ deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAcquireInfo, (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo));
}
if (local_pAcquireInfo)
{
@@ -29863,7 +29866,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPerformanceConfigurationAcquireInfoINTEL(sFeatureBits, (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;
@@ -29878,7 +29881,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPerformanceConfigurationAcquireInfoINTEL(stream, (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));
@@ -30015,7 +30018,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkPerformanceParameterTypeINTEL);
- count_VkPerformanceValueINTEL(sFeatureBits, (VkPerformanceValueINTEL*)(pValue), countPtr);
+ count_VkPerformanceValueINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceValueINTEL*)(pValue), countPtr);
}
uint32_t packetSize_vkGetPerformanceParameterINTEL = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPerformanceParameterINTEL);
@@ -30031,8 +30034,8 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkPerformanceParameterTypeINTEL*)&local_parameter, sizeof(VkPerformanceParameterTypeINTEL));
*streamPtrPtr += sizeof(VkPerformanceParameterTypeINTEL);
- reservedmarshal_VkPerformanceValueINTEL(stream, (VkPerformanceValueINTEL*)(pValue), streamPtrPtr);
- unmarshal_VkPerformanceValueINTEL(stream, (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));
@@ -30129,13 +30132,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkImagePipeSurfaceCreateInfoFUCHSIA*)pool->alloc(sizeof(const VkImagePipeSurfaceCreateInfoFUCHSIA));
- deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(pool, pCreateInfo, (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo));
+ deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -30151,12 +30154,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImagePipeSurfaceCreateInfoFUCHSIA(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -30173,7 +30176,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(stream, (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);
@@ -30181,7 +30184,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -30226,13 +30229,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkMetalSurfaceCreateInfoEXT*)pool->alloc(sizeof(const VkMetalSurfaceCreateInfoEXT));
- deepcopy_VkMetalSurfaceCreateInfoEXT(pool, pCreateInfo, (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ deepcopy_VkMetalSurfaceCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -30248,12 +30251,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMetalSurfaceCreateInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -30270,7 +30273,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMetalSurfaceCreateInfoEXT(stream, (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);
@@ -30278,7 +30281,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -30302,119 +30305,7 @@
}
#endif
-#ifdef VK_GOOGLE_color_buffer
-VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(
- VkDevice device,
- VkImage image,
- uint32_t colorBuffer,
- uint32_t doLock)
-{
- (void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
- if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- auto stream = mImpl->stream();
- auto pool = mImpl->pool();
- VkDevice local_device;
- VkImage local_image;
- uint32_t local_colorBuffer;
- local_device = device;
- local_image = image;
- local_colorBuffer = colorBuffer;
- size_t count = 0;
- size_t* countPtr = &count;
- {
- uint64_t cgen_var_0;
- *countPtr += 1 * 8;
- uint64_t cgen_var_1;
- *countPtr += 1 * 8;
- *countPtr += sizeof(uint32_t);
- }
- uint32_t packetSize_vkRegisterImageColorBufferGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- 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); }
- 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;
- uint64_t cgen_var_1;
- *&cgen_var_1 = get_host_u64_VkImage((*&local_image));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
- *streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (uint32_t*)&local_colorBuffer, sizeof(uint32_t));
- *streamPtrPtr += sizeof(uint32_t);
- VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
- stream->read(&vkRegisterImageColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
- pool->freeAll();
- stream->clearPool();
- }
- if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
- return vkRegisterImageColorBufferGOOGLE_VkResult_return;
-}
-
-VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(
- VkDevice device,
- VkBuffer buffer,
- uint32_t colorBuffer,
- uint32_t doLock)
-{
- (void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
- if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- auto stream = mImpl->stream();
- auto pool = mImpl->pool();
- VkDevice local_device;
- VkBuffer local_buffer;
- uint32_t local_colorBuffer;
- local_device = device;
- local_buffer = buffer;
- local_colorBuffer = colorBuffer;
- size_t count = 0;
- size_t* countPtr = &count;
- {
- uint64_t cgen_var_0;
- *countPtr += 1 * 8;
- uint64_t cgen_var_1;
- *countPtr += 1 * 8;
- *countPtr += sizeof(uint32_t);
- }
- uint32_t packetSize_vkRegisterBufferColorBufferGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- 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); }
- 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;
- uint64_t cgen_var_1;
- *&cgen_var_1 = get_host_u64_VkBuffer((*&local_buffer));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
- *streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (uint32_t*)&local_colorBuffer, sizeof(uint32_t));
- *streamPtrPtr += sizeof(uint32_t);
- VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
- stream->read(&vkRegisterBufferColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
- pool->freeAll();
- stream->clearPool();
- }
- if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
- return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
-}
-
+#ifdef VK_EXT_fragment_density_map
#endif
#ifdef VK_EXT_scalar_block_layout
#endif
@@ -30454,7 +30345,7 @@
if (pInfo)
{
local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
}
if (local_pInfo)
{
@@ -30465,7 +30356,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferDeviceAddressEXT);
@@ -30479,7 +30370,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, (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;;
@@ -30526,7 +30417,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i)
{
- count_VkPhysicalDeviceToolPropertiesEXT(sFeatureBits, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i), countPtr);
+ count_VkPhysicalDeviceToolPropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i), countPtr);
}
}
}
@@ -30562,7 +30453,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i)
{
- reservedmarshal_VkPhysicalDeviceToolPropertiesEXT(stream, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceToolPropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -30589,7 +30480,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i)
{
- unmarshal_VkPhysicalDeviceToolPropertiesEXT(stream, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
+ unmarshal_VkPhysicalDeviceToolPropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
}
}
}
@@ -30653,7 +30544,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- count_VkCooperativeMatrixPropertiesNV(sFeatureBits, (VkCooperativeMatrixPropertiesNV*)(pProperties + i), countPtr);
+ count_VkCooperativeMatrixPropertiesNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCooperativeMatrixPropertiesNV*)(pProperties + i), countPtr);
}
}
}
@@ -30689,7 +30580,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- reservedmarshal_VkCooperativeMatrixPropertiesNV(stream, (VkCooperativeMatrixPropertiesNV*)(pProperties + i), streamPtrPtr);
+ reservedmarshal_VkCooperativeMatrixPropertiesNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCooperativeMatrixPropertiesNV*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -30716,7 +30607,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
{
- unmarshal_VkCooperativeMatrixPropertiesNV(stream, (VkCooperativeMatrixPropertiesNV*)(pProperties + i));
+ unmarshal_VkCooperativeMatrixPropertiesNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCooperativeMatrixPropertiesNV*)(pProperties + i));
}
}
}
@@ -30776,7 +30667,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i)
{
- count_VkFramebufferMixedSamplesCombinationNV(sFeatureBits, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i), countPtr);
+ count_VkFramebufferMixedSamplesCombinationNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i), countPtr);
}
}
}
@@ -30812,7 +30703,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i)
{
- reservedmarshal_VkFramebufferMixedSamplesCombinationNV(stream, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i), streamPtrPtr);
+ reservedmarshal_VkFramebufferMixedSamplesCombinationNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -30839,7 +30730,7 @@
{
for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i)
{
- unmarshal_VkFramebufferMixedSamplesCombinationNV(stream, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i));
+ unmarshal_VkFramebufferMixedSamplesCombinationNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i));
}
}
}
@@ -30890,7 +30781,7 @@
if (pSurfaceInfo)
{
local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
- deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
if (local_pSurfaceInfo)
{
@@ -30901,7 +30792,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
+ count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pPresentModeCount)
@@ -30930,7 +30821,7 @@
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (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);
@@ -31103,7 +30994,7 @@
if (pSurfaceInfo)
{
local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
- deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
if (local_pSurfaceInfo)
{
@@ -31114,7 +31005,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
+ count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
if (pModes)
@@ -31134,7 +31025,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (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);
@@ -31190,13 +31081,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkHeadlessSurfaceCreateInfoEXT*)pool->alloc(sizeof(const VkHeadlessSurfaceCreateInfoEXT));
- deepcopy_VkHeadlessSurfaceCreateInfoEXT(pool, pCreateInfo, (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ deepcopy_VkHeadlessSurfaceCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -31212,12 +31103,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkHeadlessSurfaceCreateInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -31234,7 +31125,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkHeadlessSurfaceCreateInfoEXT(stream, (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);
@@ -31242,7 +31133,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -31547,7 +31438,7 @@
local_pViewports = (VkViewport*)pool->alloc(((viewportCount)) * sizeof(const VkViewport));
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- deepcopy_VkViewport(pool, pViewports + i, (VkViewport*)(local_pViewports + i));
+ deepcopy_VkViewport(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewports + i, (VkViewport*)(local_pViewports + i));
}
}
if (local_pViewports)
@@ -31565,7 +31456,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- count_VkViewport(sFeatureBits, (VkViewport*)(local_pViewports + i), countPtr);
+ count_VkViewport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(local_pViewports + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetViewportWithCountEXT = 4 + 4 + count;
@@ -31586,7 +31477,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
{
- reservedmarshal_VkViewport(stream, (VkViewport*)(local_pViewports + i), streamPtrPtr);
+ reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(local_pViewports + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -31619,7 +31510,7 @@
local_pScissors = (VkRect2D*)pool->alloc(((scissorCount)) * sizeof(const VkRect2D));
for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
{
- deepcopy_VkRect2D(pool, pScissors + i, (VkRect2D*)(local_pScissors + i));
+ deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pScissors + i, (VkRect2D*)(local_pScissors + i));
}
}
if (local_pScissors)
@@ -31637,7 +31528,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
{
- count_VkRect2D(sFeatureBits, (VkRect2D*)(local_pScissors + i), countPtr);
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pScissors + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetScissorWithCountEXT = 4 + 4 + count;
@@ -31658,7 +31549,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
{
- reservedmarshal_VkRect2D(stream, (VkRect2D*)(local_pScissors + i), streamPtrPtr);
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pScissors + i), streamPtrPtr);
}
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
@@ -32108,7 +31999,7 @@
if (pInfo)
{
local_pInfo = (VkGeneratedCommandsMemoryRequirementsInfoNV*)pool->alloc(sizeof(const VkGeneratedCommandsMemoryRequirementsInfoNV));
- deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(pool, pInfo, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo));
+ deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo));
}
if (local_pInfo)
{
@@ -32119,8 +32010,8 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkGeneratedCommandsMemoryRequirementsInfoNV(sFeatureBits, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetGeneratedCommandsMemoryRequirementsNV);
@@ -32134,9 +32025,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(stream, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, (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));
@@ -32167,7 +32058,7 @@
if (pGeneratedCommandsInfo)
{
local_pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)pool->alloc(sizeof(const VkGeneratedCommandsInfoNV));
- deepcopy_VkGeneratedCommandsInfoNV(pool, pGeneratedCommandsInfo, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
+ deepcopy_VkGeneratedCommandsInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGeneratedCommandsInfo, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
}
if (local_pGeneratedCommandsInfo)
{
@@ -32178,7 +32069,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkGeneratedCommandsInfoNV(sFeatureBits, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), countPtr);
+ count_VkGeneratedCommandsInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), countPtr);
}
uint32_t packetSize_vkCmdPreprocessGeneratedCommandsNV = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPreprocessGeneratedCommandsNV -= 8;
@@ -32194,7 +32085,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkGeneratedCommandsInfoNV(stream, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), streamPtrPtr);
+ reservedmarshal_VkGeneratedCommandsInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -32224,7 +32115,7 @@
if (pGeneratedCommandsInfo)
{
local_pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)pool->alloc(sizeof(const VkGeneratedCommandsInfoNV));
- deepcopy_VkGeneratedCommandsInfoNV(pool, pGeneratedCommandsInfo, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
+ deepcopy_VkGeneratedCommandsInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGeneratedCommandsInfo, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
}
if (local_pGeneratedCommandsInfo)
{
@@ -32236,7 +32127,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkBool32);
- count_VkGeneratedCommandsInfoNV(sFeatureBits, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), countPtr);
+ count_VkGeneratedCommandsInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), countPtr);
}
uint32_t packetSize_vkCmdExecuteGeneratedCommandsNV = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdExecuteGeneratedCommandsNV -= 8;
@@ -32254,7 +32145,7 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_isPreprocessed, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- reservedmarshal_VkGeneratedCommandsInfoNV(stream, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), streamPtrPtr);
+ reservedmarshal_VkGeneratedCommandsInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -32345,13 +32236,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkIndirectCommandsLayoutCreateInfoNV*)pool->alloc(sizeof(const VkIndirectCommandsLayoutCreateInfoNV));
- deepcopy_VkIndirectCommandsLayoutCreateInfoNV(pool, pCreateInfo, (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo));
+ deepcopy_VkIndirectCommandsLayoutCreateInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -32367,12 +32258,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkIndirectCommandsLayoutCreateInfoNV(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -32389,7 +32280,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkIndirectCommandsLayoutCreateInfoNV(stream, (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);
@@ -32397,7 +32288,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -32442,7 +32333,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -32460,7 +32351,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyIndirectCommandsLayoutNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -32486,7 +32377,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkIndirectCommandsLayoutNV((VkIndirectCommandsLayoutNV*)&indirectCommandsLayout);
stream->flush();
@@ -32533,13 +32424,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkPrivateDataSlotCreateInfoEXT*)pool->alloc(sizeof(const VkPrivateDataSlotCreateInfoEXT));
- deepcopy_VkPrivateDataSlotCreateInfoEXT(pool, pCreateInfo, (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo));
+ deepcopy_VkPrivateDataSlotCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -32555,12 +32446,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPrivateDataSlotCreateInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
@@ -32576,7 +32467,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPrivateDataSlotCreateInfoEXT(stream, (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);
@@ -32584,7 +32475,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ 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);
@@ -32623,7 +32514,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -32640,7 +32531,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyPrivateDataSlotEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -32666,7 +32557,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
stream->flush();
++encodeCount;;
@@ -32898,13 +32789,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkDirectFBSurfaceCreateInfoEXT*)pool->alloc(sizeof(const VkDirectFBSurfaceCreateInfoEXT));
- deepcopy_VkDirectFBSurfaceCreateInfoEXT(pool, pCreateInfo, (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ deepcopy_VkDirectFBSurfaceCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -32920,12 +32811,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDirectFBSurfaceCreateInfoEXT(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -32942,7 +32833,7 @@
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDirectFBSurfaceCreateInfoEXT(stream, (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);
@@ -32950,7 +32841,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -33027,6 +32918,118 @@
#endif
#ifdef VK_GOOGLE_gfxstream
+VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(
+ VkDevice device,
+ VkImage image,
+ uint32_t colorBuffer,
+ uint32_t doLock)
+{
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkImage local_image;
+ uint32_t local_colorBuffer;
+ local_device = device;
+ local_image = image;
+ local_colorBuffer = colorBuffer;
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ uint64_t cgen_var_1;
+ *countPtr += 1 * 8;
+ *countPtr += sizeof(uint32_t);
+ }
+ uint32_t packetSize_vkRegisterImageColorBufferGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ 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); }
+ 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;
+ uint64_t cgen_var_1;
+ *&cgen_var_1 = get_host_u64_VkImage((*&local_image));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ memcpy(*streamPtrPtr, (uint32_t*)&local_colorBuffer, sizeof(uint32_t));
+ *streamPtrPtr += sizeof(uint32_t);
+ VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
+ stream->read(&vkRegisterImageColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
+ ++encodeCount;;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL)
+ {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+ return vkRegisterImageColorBufferGOOGLE_VkResult_return;
+}
+
+VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(
+ VkDevice device,
+ VkBuffer buffer,
+ uint32_t colorBuffer,
+ uint32_t doLock)
+{
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkBuffer local_buffer;
+ uint32_t local_colorBuffer;
+ local_device = device;
+ local_buffer = buffer;
+ local_colorBuffer = colorBuffer;
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ uint64_t cgen_var_1;
+ *countPtr += 1 * 8;
+ *countPtr += sizeof(uint32_t);
+ }
+ uint32_t packetSize_vkRegisterBufferColorBufferGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ 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); }
+ 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;
+ uint64_t cgen_var_1;
+ *&cgen_var_1 = get_host_u64_VkBuffer((*&local_buffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ memcpy(*streamPtrPtr, (uint32_t*)&local_colorBuffer, sizeof(uint32_t));
+ *streamPtrPtr += sizeof(uint32_t);
+ VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
+ stream->read(&vkRegisterBufferColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
+ ++encodeCount;;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL)
+ {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+ return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
+}
+
VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(
VkDevice device,
VkDeviceMemory memory,
@@ -33158,7 +33161,7 @@
local_pImageInfos = (VkDescriptorImageInfo*)pool->alloc(((imageInfoCount)) * sizeof(const VkDescriptorImageInfo));
for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
{
- deepcopy_VkDescriptorImageInfo(pool, pImageInfos + i, (VkDescriptorImageInfo*)(local_pImageInfos + i));
+ deepcopy_VkDescriptorImageInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageInfos + i, (VkDescriptorImageInfo*)(local_pImageInfos + i));
}
}
local_pBufferInfos = nullptr;
@@ -33167,7 +33170,7 @@
local_pBufferInfos = (VkDescriptorBufferInfo*)pool->alloc(((bufferInfoCount)) * sizeof(const VkDescriptorBufferInfo));
for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
{
- deepcopy_VkDescriptorBufferInfo(pool, pBufferInfos + i, (VkDescriptorBufferInfo*)(local_pBufferInfos + i));
+ deepcopy_VkDescriptorBufferInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferInfos + i, (VkDescriptorBufferInfo*)(local_pBufferInfos + i));
}
}
// Avoiding deepcopy for pBufferViews
@@ -33222,7 +33225,7 @@
{
for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
{
- count_VkDescriptorImageInfo(sFeatureBits, (VkDescriptorImageInfo*)(local_pImageInfos + i), countPtr);
+ count_VkDescriptorImageInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorImageInfo*)(local_pImageInfos + i), countPtr);
}
}
// WARNING PTR CHECK
@@ -33231,7 +33234,7 @@
{
for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
{
- count_VkDescriptorBufferInfo(sFeatureBits, (VkDescriptorBufferInfo*)(local_pBufferInfos + i), countPtr);
+ count_VkDescriptorBufferInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorBufferInfo*)(local_pBufferInfos + i), countPtr);
}
}
// WARNING PTR CHECK
@@ -33309,7 +33312,7 @@
{
for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
{
- reservedmarshal_VkDescriptorImageInfo(stream, (VkDescriptorImageInfo*)(local_pImageInfos + i), streamPtrPtr);
+ reservedmarshal_VkDescriptorImageInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorImageInfo*)(local_pImageInfos + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -33321,7 +33324,7 @@
{
for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
{
- reservedmarshal_VkDescriptorBufferInfo(stream, (VkDescriptorBufferInfo*)(local_pBufferInfos + i), streamPtrPtr);
+ reservedmarshal_VkDescriptorBufferInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorBufferInfo*)(local_pBufferInfos + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -33369,7 +33372,7 @@
if (pBeginInfo)
{
local_pBeginInfo = (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
- deepcopy_VkCommandBufferBeginInfo(pool, pBeginInfo, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ deepcopy_VkCommandBufferBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBeginInfo, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
}
if (local_pBeginInfo)
{
@@ -33380,7 +33383,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCommandBufferBeginInfo(sFeatureBits, (VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
+ count_VkCommandBufferBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
}
uint32_t packetSize_vkBeginCommandBufferAsyncGOOGLE = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkBeginCommandBufferAsyncGOOGLE -= 8;
@@ -33396,7 +33399,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo), streamPtrPtr);
+ reservedmarshal_VkCommandBufferBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(local_pBeginInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -33566,13 +33569,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
- deepcopy_VkImageCreateInfo(pool, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkImageCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, 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;
@@ -33589,16 +33592,16 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
- count_VkMemoryRequirements(sFeatureBits, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
+ count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
}
uint32_t packetSize_vkCreateImageWithRequirementsGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateImageWithRequirementsGOOGLE);
@@ -33612,7 +33615,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageCreateInfo(stream, (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);
@@ -33620,7 +33623,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -33628,13 +33631,13 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- reservedmarshal_VkMemoryRequirements(stream, (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, (VkMemoryRequirements*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements));
if (pMemoryRequirements)
{
transform_fromhost_VkMemoryRequirements(sResourceTracker, (VkMemoryRequirements*)(pMemoryRequirements));
@@ -33672,13 +33675,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkBufferCreateInfo*)pool->alloc(sizeof(const VkBufferCreateInfo));
- deepcopy_VkBufferCreateInfo(pool, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkBufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -33694,16 +33697,16 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferCreateInfo(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
- count_VkMemoryRequirements(sFeatureBits, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
+ count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
}
uint32_t packetSize_vkCreateBufferWithRequirementsGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateBufferWithRequirementsGOOGLE);
@@ -33717,7 +33720,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferCreateInfo(stream, (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);
@@ -33725,7 +33728,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -33733,13 +33736,13 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- reservedmarshal_VkMemoryRequirements(stream, (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, (VkMemoryRequirements*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements));
if (pMemoryRequirements)
{
transform_fromhost_VkMemoryRequirements(sResourceTracker, (VkMemoryRequirements*)(pMemoryRequirements));
@@ -33911,7 +33914,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, 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);
@@ -33926,7 +33929,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkFreeMemorySyncGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -33952,7 +33955,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ 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));
@@ -34042,7 +34045,7 @@
local_pSubmits = (VkSubmitInfo*)pool->alloc(((submitCount)) * sizeof(const VkSubmitInfo));
for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
{
- deepcopy_VkSubmitInfo(pool, pSubmits + i, (VkSubmitInfo*)(local_pSubmits + i));
+ deepcopy_VkSubmitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubmits + i, (VkSubmitInfo*)(local_pSubmits + i));
}
}
local_fence = fence;
@@ -34061,7 +34064,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
{
- count_VkSubmitInfo(sFeatureBits, (VkSubmitInfo*)(local_pSubmits + i), countPtr);
+ count_VkSubmitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubmitInfo*)(local_pSubmits + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
@@ -34082,7 +34085,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
{
- reservedmarshal_VkSubmitInfo(stream, (VkSubmitInfo*)(local_pSubmits + i), streamPtrPtr);
+ 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));
@@ -34161,7 +34164,7 @@
local_pBindInfo = (VkBindSparseInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindSparseInfo));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- deepcopy_VkBindSparseInfo(pool, pBindInfo + i, (VkBindSparseInfo*)(local_pBindInfo + i));
+ deepcopy_VkBindSparseInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfo + i, (VkBindSparseInfo*)(local_pBindInfo + i));
}
}
local_fence = fence;
@@ -34180,7 +34183,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- count_VkBindSparseInfo(sFeatureBits, (VkBindSparseInfo*)(local_pBindInfo + i), countPtr);
+ count_VkBindSparseInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindSparseInfo*)(local_pBindInfo + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
@@ -34201,7 +34204,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
- reservedmarshal_VkBindSparseInfo(stream, (VkBindSparseInfo*)(local_pBindInfo + i), streamPtrPtr);
+ 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));
@@ -34333,7 +34336,7 @@
local_pPendingDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((pendingDescriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i)
{
- deepcopy_VkWriteDescriptorSet(pool, pPendingDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i));
+ deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPendingDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i));
}
}
if (local_pPendingDescriptorWrites)
@@ -34365,7 +34368,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i)
{
- count_VkWriteDescriptorSet(sFeatureBits, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i), countPtr);
+ count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i), countPtr);
}
}
uint32_t packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -34416,7 +34419,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i)
{
- reservedmarshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i), streamPtrPtr);
+ reservedmarshal_VkWriteDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i), streamPtrPtr);
}
stream->flush();
++encodeCount;;
@@ -34533,13 +34536,13 @@
if (pCreateInfo)
{
local_pCreateInfo = (VkAccelerationStructureCreateInfoKHR*)pool->alloc(sizeof(const VkAccelerationStructureCreateInfoKHR));
- deepcopy_VkAccelerationStructureCreateInfoKHR(pool, pCreateInfo, (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo));
+ deepcopy_VkAccelerationStructureCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfo)
@@ -34555,12 +34558,12 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureCreateInfoKHR(sFeatureBits, (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, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
@@ -34577,7 +34580,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureCreateInfoKHR(stream, (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);
@@ -34585,7 +34588,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -34630,7 +34633,7 @@
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pAllocator)
@@ -34648,7 +34651,7 @@
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyAccelerationStructureKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -34674,7 +34677,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)&accelerationStructure);
stream->flush();
@@ -34711,7 +34714,7 @@
local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
(void)ppBuildRangeInfos;
@@ -34731,7 +34734,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
+ count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
}
(void)local_ppBuildRangeInfos;
}
@@ -34753,7 +34756,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
+ reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
}
(void)local_ppBuildRangeInfos;
++encodeCount;;
@@ -34793,7 +34796,7 @@
local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
// Avoiding deepcopy for pIndirectDeviceAddresses
@@ -34817,7 +34820,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
+ count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
}
*countPtr += ((infoCount)) * sizeof(VkDeviceAddress);
*countPtr += ((infoCount)) * sizeof(uint32_t);
@@ -34841,7 +34844,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
+ reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
}
memcpy(*streamPtrPtr, (VkDeviceAddress*)local_pIndirectDeviceAddresses, ((infoCount)) * sizeof(VkDeviceAddress));
*streamPtrPtr += ((infoCount)) * sizeof(VkDeviceAddress);
@@ -34884,7 +34887,7 @@
local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
(void)ppBuildRangeInfos;
@@ -34905,7 +34908,7 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
+ count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
}
(void)local_ppBuildRangeInfos;
}
@@ -34929,7 +34932,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
{
- reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
+ reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
}
(void)local_ppBuildRangeInfos;
VkResult vkBuildAccelerationStructuresKHR_VkResult_return = (VkResult)0;
@@ -34964,7 +34967,7 @@
if (pInfo)
{
local_pInfo = (VkCopyAccelerationStructureInfoKHR*)pool->alloc(sizeof(const VkCopyAccelerationStructureInfoKHR));
- deepcopy_VkCopyAccelerationStructureInfoKHR(pool, pInfo, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
+ deepcopy_VkCopyAccelerationStructureInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
}
if (local_pInfo)
{
@@ -34976,7 +34979,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkCopyAccelerationStructureInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyAccelerationStructureKHR);
@@ -34994,7 +34997,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkCopyAccelerationStructureInfoKHR(stream, (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;;
@@ -35027,7 +35030,7 @@
if (pInfo)
{
local_pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)pool->alloc(sizeof(const VkCopyAccelerationStructureToMemoryInfoKHR));
- deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(pool, pInfo, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
+ deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
}
if (local_pInfo)
{
@@ -35039,7 +35042,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkCopyAccelerationStructureToMemoryInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyAccelerationStructureToMemoryKHR);
@@ -35057,7 +35060,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(stream, (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;;
@@ -35090,7 +35093,7 @@
if (pInfo)
{
local_pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)pool->alloc(sizeof(const VkCopyMemoryToAccelerationStructureInfoKHR));
- deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(pool, pInfo, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
+ deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
}
if (local_pInfo)
{
@@ -35102,7 +35105,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkCopyMemoryToAccelerationStructureInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyMemoryToAccelerationStructureKHR);
@@ -35120,7 +35123,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(stream, (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;;
@@ -35242,7 +35245,7 @@
if (pInfo)
{
local_pInfo = (VkCopyAccelerationStructureInfoKHR*)pool->alloc(sizeof(const VkCopyAccelerationStructureInfoKHR));
- deepcopy_VkCopyAccelerationStructureInfoKHR(pool, pInfo, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
+ deepcopy_VkCopyAccelerationStructureInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
}
if (local_pInfo)
{
@@ -35253,7 +35256,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyAccelerationStructureInfoKHR(sFeatureBits, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyAccelerationStructureInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyAccelerationStructureKHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyAccelerationStructureKHR -= 8;
@@ -35269,7 +35272,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyAccelerationStructureInfoKHR(stream, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkCopyAccelerationStructureInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -35296,7 +35299,7 @@
if (pInfo)
{
local_pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)pool->alloc(sizeof(const VkCopyAccelerationStructureToMemoryInfoKHR));
- deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(pool, pInfo, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
+ deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
}
if (local_pInfo)
{
@@ -35307,7 +35310,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyAccelerationStructureToMemoryInfoKHR(sFeatureBits, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyAccelerationStructureToMemoryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyAccelerationStructureToMemoryKHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyAccelerationStructureToMemoryKHR -= 8;
@@ -35323,7 +35326,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(stream, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -35350,7 +35353,7 @@
if (pInfo)
{
local_pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)pool->alloc(sizeof(const VkCopyMemoryToAccelerationStructureInfoKHR));
- deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(pool, pInfo, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
+ deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
}
if (local_pInfo)
{
@@ -35361,7 +35364,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyMemoryToAccelerationStructureInfoKHR(sFeatureBits, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyMemoryToAccelerationStructureInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyMemoryToAccelerationStructureKHR = 4 + 4 + count;
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyMemoryToAccelerationStructureKHR -= 8;
@@ -35377,7 +35380,7 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(stream, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
++encodeCount;;
if (0 == encodeCount % POOL_CLEAR_INTERVAL)
{
@@ -35404,7 +35407,7 @@
if (pInfo)
{
local_pInfo = (VkAccelerationStructureDeviceAddressInfoKHR*)pool->alloc(sizeof(const VkAccelerationStructureDeviceAddressInfoKHR));
- deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(pool, pInfo, (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo));
+ deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo));
}
if (local_pInfo)
{
@@ -35415,7 +35418,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureDeviceAddressInfoKHR(sFeatureBits, (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;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAccelerationStructureDeviceAddressKHR);
@@ -35429,7 +35432,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureDeviceAddressInfoKHR(stream, (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo), streamPtrPtr);
+ 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;;
@@ -35545,7 +35548,7 @@
if (pVersionInfo)
{
local_pVersionInfo = (VkAccelerationStructureVersionInfoKHR*)pool->alloc(sizeof(const VkAccelerationStructureVersionInfoKHR));
- deepcopy_VkAccelerationStructureVersionInfoKHR(pool, pVersionInfo, (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo));
+ deepcopy_VkAccelerationStructureVersionInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVersionInfo, (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo));
}
if (local_pVersionInfo)
{
@@ -35556,7 +35559,7 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureVersionInfoKHR(sFeatureBits, (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;
@@ -35571,7 +35574,7 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureVersionInfoKHR(stream, (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo), streamPtrPtr);
+ 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));
@@ -35607,7 +35610,7 @@
if (pBuildInfo)
{
local_pBuildInfo = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
- deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, pBuildInfo, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo));
+ deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBuildInfo, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo));
}
// Avoiding deepcopy for pMaxPrimitiveCounts
local_pMaxPrimitiveCounts = (uint32_t*)pMaxPrimitiveCounts;
@@ -35621,9 +35624,9 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkAccelerationStructureBuildTypeKHR);
- count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo), countPtr);
+ count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo), countPtr);
*countPtr += pBuildInfo->geometryCount * sizeof(uint32_t);
- count_VkAccelerationStructureBuildSizesInfoKHR(sFeatureBits, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo), countPtr);
+ count_VkAccelerationStructureBuildSizesInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo), countPtr);
}
uint32_t packetSize_vkGetAccelerationStructureBuildSizesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAccelerationStructureBuildSizesKHR);
@@ -35639,11 +35642,11 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkAccelerationStructureBuildTypeKHR*)&local_buildType, sizeof(VkAccelerationStructureBuildTypeKHR));
*streamPtrPtr += sizeof(VkAccelerationStructureBuildTypeKHR);
- reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo), streamPtrPtr);
+ reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (uint32_t*)local_pMaxPrimitiveCounts, pBuildInfo->geometryCount * sizeof(uint32_t));
*streamPtrPtr += pBuildInfo->geometryCount * sizeof(uint32_t);
- reservedmarshal_VkAccelerationStructureBuildSizesInfoKHR(stream, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo), streamPtrPtr);
- unmarshal_VkAccelerationStructureBuildSizesInfoKHR(stream, (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));
@@ -35688,25 +35691,25 @@
if (pRaygenShaderBindingTable)
{
local_pRaygenShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, pRaygenShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
+ 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, pMissShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
+ 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, pHitShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
+ 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, pCallableShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
+ deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallableShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
}
local_width = width;
local_height = height;
@@ -35732,10 +35735,10 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, (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);
@@ -35754,10 +35757,10 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, (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));
@@ -35804,14 +35807,14 @@
local_pCreateInfos = (VkRayTracingPipelineCreateInfoKHR*)pool->alloc(((createInfoCount)) * sizeof(const VkRayTracingPipelineCreateInfoKHR));
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- deepcopy_VkRayTracingPipelineCreateInfoKHR(pool, pCreateInfos + i, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i));
+ deepcopy_VkRayTracingPipelineCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
if (pAllocator)
{
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
if (local_pCreateInfos)
@@ -35836,13 +35839,13 @@
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- count_VkRayTracingPipelineCreateInfoKHR(sFeatureBits, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i), countPtr);
+ count_VkRayTracingPipelineCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
if (local_pAllocator)
{
- count_VkAllocationCallbacks(sFeatureBits, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
if (((createInfoCount)))
{
@@ -35873,7 +35876,7 @@
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
- reservedmarshal_VkRayTracingPipelineCreateInfoKHR(stream, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i), streamPtrPtr);
+ 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;
@@ -35882,7 +35885,7 @@
*streamPtrPtr += 8;
if (local_pAllocator)
{
- reservedmarshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
}
/* is handle, possibly out */;
if (((createInfoCount)))
@@ -36015,25 +36018,25 @@
if (pRaygenShaderBindingTable)
{
local_pRaygenShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, pRaygenShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
+ 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, pMissShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
+ 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, pHitShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
+ 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, pCallableShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
+ deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallableShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
}
local_indirectDeviceAddress = indirectDeviceAddress;
if (local_pRaygenShaderBindingTable)
@@ -36057,10 +36060,10 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, (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;
@@ -36077,10 +36080,10 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, (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;;
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
index d61dbb3..160632a 100644
--- a/system/vulkan_enc/VkEncoder.h
+++ b/system/vulkan_enc/VkEncoder.h
@@ -2597,17 +2597,7 @@
VkSurfaceKHR* pSurface,
uint32_t doLock);
#endif
-#ifdef VK_GOOGLE_color_buffer
- VkResult vkRegisterImageColorBufferGOOGLE(
- VkDevice device,
- VkImage image,
- uint32_t colorBuffer,
- uint32_t doLock);
- VkResult vkRegisterBufferColorBufferGOOGLE(
- VkDevice device,
- VkBuffer buffer,
- uint32_t colorBuffer,
- uint32_t doLock);
+#ifdef VK_EXT_fragment_density_map
#endif
#ifdef VK_EXT_scalar_block_layout
#endif
@@ -2882,6 +2872,16 @@
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,
diff --git a/system/vulkan_enc/VulkanHandles.h b/system/vulkan_enc/VulkanHandles.h
index a233408..b0f4f6c 100644
--- a/system/vulkan_enc/VulkanHandles.h
+++ b/system/vulkan_enc/VulkanHandles.h
@@ -86,7 +86,6 @@
f(VkBufferView) \
f(VkImageView) \
f(VkShaderModule) \
- f(VkSampler) \
f(VkPipeline) \
f(VkPipelineCache) \
f(VkPipelineLayout) \
@@ -118,6 +117,7 @@
f(VkDescriptorSet) \
f(VkDescriptorSetLayout) \
f(VkCommandPool) \
+ f(VkSampler) \
__GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
@@ -129,6 +129,12 @@
GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
+#define GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_DISPATCHABLE_HANDLE_TYPES(f) \
+ f(VkInstance) \
+ f(VkDevice) \
+ f(VkQueue) \
+ GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
+
#define GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(f) \
f(VkDeviceMemory) \
f(VkBuffer) \
@@ -137,6 +143,7 @@
f(VkFence) \
f(VkDescriptorUpdateTemplate) \
f(VkCommandPool) \
+ f(VkSampler) \
__GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
diff --git a/system/vulkan_enc/func_table.cpp b/system/vulkan_enc/func_table.cpp
index 3199d88..dc3f66d 100644
--- a/system/vulkan_enc/func_table.cpp
+++ b/system/vulkan_enc/func_table.cpp
@@ -1025,7 +1025,8 @@
AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
- vkAllocateCommandBuffers_VkResult_return = vkEnc->vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers, true /* do lock */);
+ auto resources = ResourceTracker::get();
+ 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);
}
@@ -6435,61 +6436,7 @@
return vkCreateMetalSurfaceEXT_VkResult_return;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
-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 */);
- return vkRegisterImageColorBufferGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkRegisterImageColorBufferGOOGLE(
- VkDevice device,
- VkImage image,
- uint32_t colorBuffer)
-{
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_color_buffer"))
- {
- sOnInvalidDynamicallyCheckedCall("vkRegisterImageColorBufferGOOGLE", "VK_GOOGLE_color_buffer");
- }
- 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 */);
- return vkRegisterImageColorBufferGOOGLE_VkResult_return;
-}
-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 */);
- return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkRegisterBufferColorBufferGOOGLE(
- VkDevice device,
- VkBuffer buffer,
- uint32_t colorBuffer)
-{
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_color_buffer"))
- {
- sOnInvalidDynamicallyCheckedCall("vkRegisterBufferColorBufferGOOGLE", "VK_GOOGLE_color_buffer");
- }
- 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 */);
- return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
-}
+#ifdef VK_EXT_fragment_density_map
#endif
#ifdef VK_EXT_scalar_block_layout
#endif
@@ -7122,6 +7069,60 @@
}
#endif
#ifdef VK_GOOGLE_gfxstream
+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 */);
+ return vkRegisterImageColorBufferGOOGLE_VkResult_return;
+}
+static VkResult dynCheck_entry_vkRegisterImageColorBufferGOOGLE(
+ VkDevice device,
+ VkImage image,
+ uint32_t colorBuffer)
+{
+ auto resources = ResourceTracker::get();
+ 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 */);
+ return vkRegisterImageColorBufferGOOGLE_VkResult_return;
+}
+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 */);
+ return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
+}
+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");
+ }
+ 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 */);
+ return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
+}
static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE(
VkDevice device,
VkDeviceMemory memory,
@@ -9672,16 +9673,6 @@
return nullptr;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
- {
- return nullptr;
- }
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
- {
- return nullptr;
- }
-#endif
#ifdef VK_EXT_buffer_device_address
if (!strcmp(name, "vkGetBufferDeviceAddressEXT"))
{
@@ -9853,6 +9844,14 @@
}
#endif
#ifdef VK_GOOGLE_gfxstream
+ if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
+ {
+ return nullptr;
+ }
+ if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
+ {
+ return nullptr;
+ }
if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE"))
{
return nullptr;
@@ -11899,16 +11898,6 @@
return hasExt ? (void*)entry_vkCreateMetalSurfaceEXT : nullptr;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
- {
- return (void*)dynCheck_entry_vkRegisterImageColorBufferGOOGLE;
- }
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
- {
- return (void*)dynCheck_entry_vkRegisterBufferColorBufferGOOGLE;
- }
-#endif
#ifdef VK_EXT_buffer_device_address
if (!strcmp(name, "vkGetBufferDeviceAddressEXT"))
{
@@ -12104,6 +12093,14 @@
}
#endif
#ifdef VK_GOOGLE_gfxstream
+ if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
+ {
+ return (void*)dynCheck_entry_vkRegisterImageColorBufferGOOGLE;
+ }
+ if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
+ {
+ return (void*)dynCheck_entry_vkRegisterBufferColorBufferGOOGLE;
+ }
if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE"))
{
return (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE;
@@ -14269,18 +14266,6 @@
return hasExt ? (void*)entry_vkCreateMetalSurfaceEXT : nullptr;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_color_buffer");
- return hasExt ? (void*)entry_vkRegisterImageColorBufferGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_color_buffer");
- return hasExt ? (void*)entry_vkRegisterBufferColorBufferGOOGLE : nullptr;
- }
-#endif
#ifdef VK_EXT_buffer_device_address
if (!strcmp(name, "vkGetBufferDeviceAddressEXT"))
{
@@ -14488,6 +14473,16 @@
}
#endif
#ifdef VK_GOOGLE_gfxstream
+ if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
+ {
+ bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)entry_vkRegisterImageColorBufferGOOGLE : nullptr;
+ }
+ if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
+ {
+ bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)entry_vkRegisterBufferColorBufferGOOGLE : nullptr;
+ }
if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE"))
{
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
diff --git a/system/vulkan_enc/func_table.h b/system/vulkan_enc/func_table.h
index 39f2e02..3c12410 100644
--- a/system/vulkan_enc/func_table.h
+++ b/system/vulkan_enc/func_table.h
@@ -388,7 +388,7 @@
#endif
#ifdef VK_EXT_metal_surface
#endif
-#ifdef VK_GOOGLE_color_buffer
+#ifdef VK_EXT_fragment_density_map
#endif
#ifdef VK_EXT_scalar_block_layout
#endif
diff --git a/system/vulkan_enc/goldfish_vk_counting_guest.cpp b/system/vulkan_enc/goldfish_vk_counting_guest.cpp
index cc187cc..4e42832 100644
--- a/system/vulkan_enc/goldfish_vk_counting_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_counting_guest.cpp
@@ -33,16 +33,19 @@
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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -51,10 +54,12 @@
void count_VkExtent3D(
uint32_t featureBits,
+ VkStructureType rootType,
const VkExtent3D* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -64,10 +69,12 @@
void count_VkOffset2D(
uint32_t featureBits,
+ VkStructureType rootType,
const VkOffset2D* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(int32_t);
@@ -76,10 +83,12 @@
void count_VkOffset3D(
uint32_t featureBits,
+ VkStructureType rootType,
const VkOffset3D* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(int32_t);
@@ -89,50 +98,70 @@
void count_VkRect2D(
uint32_t featureBits,
+ VkStructureType rootType,
const VkRect2D* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
- count_VkOffset2D(featureBits, (VkOffset2D*)(&toCount->offset), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->extent), count);
+ count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->offset), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->extent), 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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAccessFlags);
*count += sizeof(VkAccessFlags);
*count += sizeof(uint32_t);
@@ -145,10 +174,12 @@
void count_VkDispatchIndirectCommand(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDispatchIndirectCommand* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -158,10 +189,12 @@
void count_VkDrawIndexedIndirectCommand(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDrawIndexedIndirectCommand* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -173,10 +206,12 @@
void count_VkDrawIndirectCommand(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDrawIndirectCommand* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -187,10 +222,12 @@
void count_VkImageSubresourceRange(
uint32_t featureBits,
+ VkStructureType rootType,
const VkImageSubresourceRange* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkImageAspectFlags);
@@ -202,14 +239,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAccessFlags);
*count += sizeof(VkAccessFlags);
*count += sizeof(VkImageLayout);
@@ -218,29 +261,37 @@
*count += sizeof(uint32_t);
uint64_t cgen_var_0;
*count += 1 * 8;
- count_VkImageSubresourceRange(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAccessFlags);
*count += sizeof(VkAccessFlags);
}
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
@@ -258,14 +309,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
// WARNING PTR CHECK
@@ -299,10 +356,12 @@
void count_VkFormatProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkFormatProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkFormatFeatureFlags);
@@ -312,13 +371,15 @@
void count_VkImageFormatProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkImageFormatProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->maxExtent), count);
+ count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->maxExtent), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(VkSampleCountFlags);
@@ -327,20 +388,26 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkApplicationInfo*)(toCount->pApplicationInfo), count);
+ count_VkApplicationInfo(featureBits, rootType, (const VkApplicationInfo*)(toCount->pApplicationInfo), count);
}
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -366,10 +433,12 @@
void count_VkMemoryHeap(
uint32_t featureBits,
+ VkStructureType rootType,
const VkMemoryHeap* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceSize);
@@ -378,10 +447,12 @@
void count_VkMemoryType(
uint32_t featureBits,
+ VkStructureType rootType,
const VkMemoryType* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkMemoryPropertyFlags);
@@ -390,10 +461,12 @@
void count_VkPhysicalDeviceFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkBool32);
@@ -455,10 +528,12 @@
void count_VkPhysicalDeviceLimits(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceLimits* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -571,30 +646,34 @@
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)
{
- count_VkMemoryType(featureBits, (VkMemoryType*)(toCount->memoryTypes + i), count);
+ 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)
{
- count_VkMemoryHeap(featureBits, (VkMemoryHeap*)(toCount->memoryHeaps + i), count);
+ count_VkMemoryHeap(featureBits, rootType, (VkMemoryHeap*)(toCount->memoryHeaps + i), count);
}
}
void count_VkPhysicalDeviceSparseProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkBool32);
@@ -606,10 +685,12 @@
void count_VkPhysicalDeviceProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -619,34 +700,42 @@
*count += sizeof(VkPhysicalDeviceType);
*count += VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char);
*count += VK_UUID_SIZE * sizeof(uint8_t);
- count_VkPhysicalDeviceLimits(featureBits, (VkPhysicalDeviceLimits*)(&toCount->limits), count);
- count_VkPhysicalDeviceSparseProperties(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkQueueFlags);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- count_VkExtent3D(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -658,21 +747,27 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkDeviceQueueCreateInfo*)(toCount->pQueueCreateInfos + i), count);
+ count_VkDeviceQueueCreateInfo(featureBits, rootType, (const VkDeviceQueueCreateInfo*)(toCount->pQueueCreateInfos + i), count);
}
}
*count += sizeof(uint32_t);
@@ -699,16 +794,18 @@
*count += 8;
if (toCount->pEnabledFeatures)
{
- count_VkPhysicalDeviceFeatures(featureBits, (const VkPhysicalDeviceFeatures*)(toCount->pEnabledFeatures), count);
+ count_VkPhysicalDeviceFeatures(featureBits, rootType, (const VkPhysicalDeviceFeatures*)(toCount->pEnabledFeatures), count);
}
}
void count_VkExtensionProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkExtensionProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
@@ -717,10 +814,12 @@
void count_VkLayerProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkLayerProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
@@ -731,14 +830,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -762,14 +867,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkDeviceSize);
@@ -778,24 +889,32 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
}
void count_VkMemoryRequirements(
uint32_t featureBits,
+ VkStructureType rootType,
const VkMemoryRequirements* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceSize);
@@ -805,10 +924,12 @@
void count_VkSparseMemoryBind(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSparseMemoryBind* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceSize);
@@ -821,10 +942,12 @@
void count_VkSparseBufferMemoryBindInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSparseBufferMemoryBindInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
@@ -834,17 +957,19 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i)
{
- count_VkSparseMemoryBind(featureBits, (const VkSparseMemoryBind*)(toCount->pBinds + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
@@ -854,17 +979,19 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i)
{
- count_VkSparseMemoryBind(featureBits, (const VkSparseMemoryBind*)(toCount->pBinds + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkImageAspectFlags);
@@ -874,15 +1001,17 @@
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, (VkImageSubresource*)(&toCount->subresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->offset), count);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->extent), 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;
*count += 1 * 8;
*count += sizeof(VkDeviceSize);
@@ -891,10 +1020,12 @@
void count_VkSparseImageMemoryBindInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSparseImageMemoryBindInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
@@ -904,21 +1035,27 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i)
{
- count_VkSparseImageMemoryBind(featureBits, (const VkSparseImageMemoryBind*)(toCount->pBinds + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -929,7 +1066,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->bufferBindCount; ++i)
{
- count_VkSparseBufferMemoryBindInfo(featureBits, (const VkSparseBufferMemoryBindInfo*)(toCount->pBufferBinds + i), count);
+ count_VkSparseBufferMemoryBindInfo(featureBits, rootType, (const VkSparseBufferMemoryBindInfo*)(toCount->pBufferBinds + i), count);
}
}
*count += sizeof(uint32_t);
@@ -937,7 +1074,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->imageOpaqueBindCount; ++i)
{
- count_VkSparseImageOpaqueMemoryBindInfo(featureBits, (const VkSparseImageOpaqueMemoryBindInfo*)(toCount->pImageOpaqueBinds + i), count);
+ count_VkSparseImageOpaqueMemoryBindInfo(featureBits, rootType, (const VkSparseImageOpaqueMemoryBindInfo*)(toCount->pImageOpaqueBinds + i), count);
}
}
*count += sizeof(uint32_t);
@@ -945,7 +1082,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->imageBindCount; ++i)
{
- count_VkSparseImageMemoryBindInfo(featureBits, (const VkSparseImageMemoryBindInfo*)(toCount->pImageBinds + i), count);
+ count_VkSparseImageMemoryBindInfo(featureBits, rootType, (const VkSparseImageMemoryBindInfo*)(toCount->pImageBinds + i), count);
}
}
*count += sizeof(uint32_t);
@@ -957,26 +1094,30 @@
void count_VkSparseImageFormatProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSparseImageFormatProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkImageAspectFlags);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->imageGranularity), count);
+ count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageGranularity), count);
*count += sizeof(VkSparseImageFormatFlags);
}
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, (VkSparseImageFormatProperties*)(&toCount->formatProperties), count);
+ count_VkSparseImageFormatProperties(featureBits, rootType, (VkSparseImageFormatProperties*)(&toCount->formatProperties), count);
*count += sizeof(uint32_t);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
@@ -985,53 +1126,77 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkQueryPoolCreateFlags);
*count += sizeof(VkQueryType);
*count += sizeof(uint32_t);
@@ -1040,14 +1205,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBufferCreateFlags);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkBufferUsageFlags);
@@ -1066,14 +1237,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBufferViewCreateFlags);
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -1084,18 +1261,24 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageCreateFlags);
*count += sizeof(VkImageType);
*count += sizeof(VkFormat);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->extent), count);
+ count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(VkSampleCountFlagBits);
@@ -1117,10 +1300,12 @@
void count_VkSubresourceLayout(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSubresourceLayout* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceSize);
@@ -1132,10 +1317,12 @@
void count_VkComponentMapping(
uint32_t featureBits,
+ VkStructureType rootType,
const VkComponentMapping* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkComponentSwizzle);
@@ -1146,33 +1333,45 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageViewCreateFlags);
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(VkImageViewType);
*count += sizeof(VkFormat);
- count_VkComponentMapping(featureBits, (VkComponentMapping*)(&toCount->components), count);
- count_VkImageSubresourceRange(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -1183,14 +1382,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -1201,10 +1406,12 @@
void count_VkSpecializationMapEntry(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSpecializationMapEntry* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -1214,10 +1421,12 @@
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);
@@ -1225,7 +1434,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->mapEntryCount; ++i)
{
- count_VkSpecializationMapEntry(featureBits, (const VkSpecializationMapEntry*)(toCount->pMapEntries + i), count);
+ count_VkSpecializationMapEntry(featureBits, rootType, (const VkSpecializationMapEntry*)(toCount->pMapEntries + i), count);
}
}
*count += 8;
@@ -1237,14 +1446,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineShaderStageCreateFlags);
*count += sizeof(VkShaderStageFlagBits);
uint64_t cgen_var_0;
@@ -1254,22 +1469,28 @@
*count += 8;
if (toCount->pSpecializationInfo)
{
- count_VkSpecializationInfo(featureBits, (const VkSpecializationInfo*)(toCount->pSpecializationInfo), count);
+ count_VkSpecializationInfo(featureBits, rootType, (const VkSpecializationInfo*)(toCount->pSpecializationInfo), 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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCreateFlags);
- count_VkPipelineShaderStageCreateInfo(featureBits, (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;
@@ -1279,10 +1500,12 @@
void count_VkVertexInputBindingDescription(
uint32_t featureBits,
+ VkStructureType rootType,
const VkVertexInputBindingDescription* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -1292,10 +1515,12 @@
void count_VkVertexInputAttributeDescription(
uint32_t featureBits,
+ VkStructureType rootType,
const VkVertexInputAttributeDescription* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -1306,21 +1531,27 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkVertexInputBindingDescription*)(toCount->pVertexBindingDescriptions + i), count);
+ count_VkVertexInputBindingDescription(featureBits, rootType, (const VkVertexInputBindingDescription*)(toCount->pVertexBindingDescriptions + i), count);
}
}
*count += sizeof(uint32_t);
@@ -1328,21 +1559,27 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->vertexAttributeDescriptionCount; ++i)
{
- count_VkVertexInputAttributeDescription(featureBits, (const VkVertexInputAttributeDescription*)(toCount->pVertexAttributeDescriptions + i), count);
+ count_VkVertexInputAttributeDescription(featureBits, rootType, (const VkVertexInputAttributeDescription*)(toCount->pVertexAttributeDescriptions + i), count);
}
}
}
void count_VkPipelineInputAssemblyStateCreateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineInputAssemblyStateCreateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineInputAssemblyStateCreateFlags);
*count += sizeof(VkPrimitiveTopology);
*count += sizeof(VkBool32);
@@ -1350,24 +1587,32 @@
void count_VkPipelineTessellationStateCreateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineTessellationStateCreateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineTessellationStateCreateFlags);
*count += sizeof(uint32_t);
}
void count_VkViewport(
uint32_t featureBits,
+ VkStructureType rootType,
const VkViewport* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(float);
@@ -1380,14 +1625,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineViewportStateCreateFlags);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -1398,7 +1649,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i)
{
- count_VkViewport(featureBits, (const VkViewport*)(toCount->pViewports + i), count);
+ count_VkViewport(featureBits, rootType, (const VkViewport*)(toCount->pViewports + i), count);
}
}
}
@@ -1411,7 +1662,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->scissorCount; ++i)
{
- count_VkRect2D(featureBits, (const VkRect2D*)(toCount->pScissors + i), count);
+ count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pScissors + i), count);
}
}
}
@@ -1419,14 +1670,20 @@
void count_VkPipelineRasterizationStateCreateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationStateCreateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineRasterizationStateCreateFlags);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -1442,14 +1699,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineMultisampleStateCreateFlags);
*count += sizeof(VkSampleCountFlagBits);
*count += sizeof(VkBool32);
@@ -1469,10 +1732,12 @@
void count_VkStencilOpState(
uint32_t featureBits,
+ VkStructureType rootType,
const VkStencilOpState* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStencilOp);
@@ -1486,32 +1751,40 @@
void count_VkPipelineDepthStencilStateCreateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineDepthStencilStateCreateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineDepthStencilStateCreateFlags);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkCompareOp);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
- count_VkStencilOpState(featureBits, (VkStencilOpState*)(&toCount->front), count);
- count_VkStencilOpState(featureBits, (VkStencilOpState*)(&toCount->back), count);
+ count_VkStencilOpState(featureBits, rootType, (VkStencilOpState*)(&toCount->front), count);
+ count_VkStencilOpState(featureBits, rootType, (VkStencilOpState*)(&toCount->back), count);
*count += sizeof(float);
*count += sizeof(float);
}
void count_VkPipelineColorBlendAttachmentState(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineColorBlendAttachmentState* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkBool32);
@@ -1526,14 +1799,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineColorBlendStateCreateFlags);
*count += sizeof(VkBool32);
*count += sizeof(VkLogicOp);
@@ -1542,7 +1821,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i)
{
- count_VkPipelineColorBlendAttachmentState(featureBits, (const VkPipelineColorBlendAttachmentState*)(toCount->pAttachments + i), count);
+ count_VkPipelineColorBlendAttachmentState(featureBits, rootType, (const VkPipelineColorBlendAttachmentState*)(toCount->pAttachments + i), count);
}
}
*count += 4 * sizeof(float);
@@ -1550,14 +1829,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -1568,10 +1853,12 @@
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;
@@ -1587,14 +1874,18 @@
*count += 4;
}
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
+ count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
}
}
// WARNING PTR CHECK
@@ -1604,7 +1895,7 @@
}
if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || toCount->pVertexInputState))
{
- count_VkPipelineVertexInputStateCreateInfo(featureBits, (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
+ count_VkPipelineVertexInputStateCreateInfo(featureBits, rootType, (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
}
// WARNING PTR CHECK
if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
@@ -1613,7 +1904,7 @@
}
if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || toCount->pInputAssemblyState))
{
- count_VkPipelineInputAssemblyStateCreateInfo(featureBits, (const VkPipelineInputAssemblyStateCreateInfo*)(toCount->pInputAssemblyState), count);
+ count_VkPipelineInputAssemblyStateCreateInfo(featureBits, rootType, (const VkPipelineInputAssemblyStateCreateInfo*)(toCount->pInputAssemblyState), count);
}
// WARNING PTR CHECK
*count += 8;
@@ -1621,7 +1912,7 @@
{
if (hasTessellation)
{
- count_VkPipelineTessellationStateCreateInfo(featureBits, (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
+ count_VkPipelineTessellationStateCreateInfo(featureBits, rootType, (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
}
}
// WARNING PTR CHECK
@@ -1630,7 +1921,7 @@
{
if (hasRasterization)
{
- count_VkPipelineViewportStateCreateInfo(featureBits, (const VkPipelineViewportStateCreateInfo*)(toCount->pViewportState), count);
+ count_VkPipelineViewportStateCreateInfo(featureBits, rootType, (const VkPipelineViewportStateCreateInfo*)(toCount->pViewportState), count);
}
}
// WARNING PTR CHECK
@@ -1640,7 +1931,7 @@
}
if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || toCount->pRasterizationState))
{
- count_VkPipelineRasterizationStateCreateInfo(featureBits, (const VkPipelineRasterizationStateCreateInfo*)(toCount->pRasterizationState), count);
+ count_VkPipelineRasterizationStateCreateInfo(featureBits, rootType, (const VkPipelineRasterizationStateCreateInfo*)(toCount->pRasterizationState), count);
}
// WARNING PTR CHECK
*count += 8;
@@ -1648,7 +1939,7 @@
{
if (hasRasterization)
{
- count_VkPipelineMultisampleStateCreateInfo(featureBits, (const VkPipelineMultisampleStateCreateInfo*)(toCount->pMultisampleState), count);
+ count_VkPipelineMultisampleStateCreateInfo(featureBits, rootType, (const VkPipelineMultisampleStateCreateInfo*)(toCount->pMultisampleState), count);
}
}
// WARNING PTR CHECK
@@ -1657,7 +1948,7 @@
{
if (hasRasterization)
{
- count_VkPipelineDepthStencilStateCreateInfo(featureBits, (const VkPipelineDepthStencilStateCreateInfo*)(toCount->pDepthStencilState), count);
+ count_VkPipelineDepthStencilStateCreateInfo(featureBits, rootType, (const VkPipelineDepthStencilStateCreateInfo*)(toCount->pDepthStencilState), count);
}
}
// WARNING PTR CHECK
@@ -1666,14 +1957,14 @@
{
if (hasRasterization)
{
- count_VkPipelineColorBlendStateCreateInfo(featureBits, (const VkPipelineColorBlendStateCreateInfo*)(toCount->pColorBlendState), count);
+ count_VkPipelineColorBlendStateCreateInfo(featureBits, rootType, (const VkPipelineColorBlendStateCreateInfo*)(toCount->pColorBlendState), count);
}
}
// WARNING PTR CHECK
*count += 8;
if (toCount->pDynamicState)
{
- count_VkPipelineDynamicStateCreateInfo(featureBits, (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
+ count_VkPipelineDynamicStateCreateInfo(featureBits, rootType, (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
}
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -1687,10 +1978,12 @@
void count_VkPushConstantRange(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPushConstantRange* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkShaderStageFlags);
@@ -1700,14 +1993,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -1719,21 +2018,27 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->pushConstantRangeCount; ++i)
{
- count_VkPushConstantRange(featureBits, (const VkPushConstantRange*)(toCount->pPushConstantRanges + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSamplerCreateFlags);
*count += sizeof(VkFilter);
*count += sizeof(VkFilter);
@@ -1754,14 +2059,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -1775,10 +2086,12 @@
void count_VkDescriptorBufferInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDescriptorBufferInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
@@ -1789,10 +2102,12 @@
void count_VkDescriptorImageInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDescriptorImageInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
@@ -1804,10 +2119,12 @@
void count_VkDescriptorPoolSize(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDescriptorPoolSize* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDescriptorType);
@@ -1816,14 +2133,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -1831,21 +2154,27 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->poolSizeCount; ++i)
{
- count_VkDescriptorPoolSize(featureBits, (const VkDescriptorPoolSize*)(toCount->pPoolSizes + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -1857,10 +2186,12 @@
void count_VkDescriptorSetLayoutBinding(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBinding* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -1880,35 +2211,47 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkDescriptorSetLayoutBinding*)(toCount->pBindings + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -1925,7 +2268,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->descriptorCount; ++i)
{
- count_VkDescriptorImageInfo(featureBits, (const VkDescriptorImageInfo*)(toCount->pImageInfo + i), count);
+ count_VkDescriptorImageInfo(featureBits, rootType, (const VkDescriptorImageInfo*)(toCount->pImageInfo + i), count);
}
}
}
@@ -1940,7 +2283,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->descriptorCount; ++i)
{
- count_VkDescriptorBufferInfo(featureBits, (const VkDescriptorBufferInfo*)(toCount->pBufferInfo + i), count);
+ count_VkDescriptorBufferInfo(featureBits, rootType, (const VkDescriptorBufferInfo*)(toCount->pBufferInfo + i), count);
}
}
}
@@ -1961,10 +2304,12 @@
void count_VkAttachmentDescription(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAttachmentDescription* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkAttachmentDescriptionFlags);
@@ -1980,10 +2325,12 @@
void count_VkAttachmentReference(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAttachmentReference* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -1992,14 +2339,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFramebufferCreateFlags);
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -2015,10 +2368,12 @@
void count_VkSubpassDescription(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSubpassDescription* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkSubpassDescriptionFlags);
@@ -2028,7 +2383,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->inputAttachmentCount; ++i)
{
- count_VkAttachmentReference(featureBits, (const VkAttachmentReference*)(toCount->pInputAttachments + i), count);
+ count_VkAttachmentReference(featureBits, rootType, (const VkAttachmentReference*)(toCount->pInputAttachments + i), count);
}
}
*count += sizeof(uint32_t);
@@ -2036,7 +2391,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
{
- count_VkAttachmentReference(featureBits, (const VkAttachmentReference*)(toCount->pColorAttachments + i), count);
+ count_VkAttachmentReference(featureBits, rootType, (const VkAttachmentReference*)(toCount->pColorAttachments + i), count);
}
}
// WARNING PTR CHECK
@@ -2047,7 +2402,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
{
- count_VkAttachmentReference(featureBits, (const VkAttachmentReference*)(toCount->pResolveAttachments + i), count);
+ count_VkAttachmentReference(featureBits, rootType, (const VkAttachmentReference*)(toCount->pResolveAttachments + i), count);
}
}
}
@@ -2055,7 +2410,7 @@
*count += 8;
if (toCount->pDepthStencilAttachment)
{
- count_VkAttachmentReference(featureBits, (const VkAttachmentReference*)(toCount->pDepthStencilAttachment), count);
+ count_VkAttachmentReference(featureBits, rootType, (const VkAttachmentReference*)(toCount->pDepthStencilAttachment), count);
}
*count += sizeof(uint32_t);
if (toCount)
@@ -2066,10 +2421,12 @@
void count_VkSubpassDependency(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSubpassDependency* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -2083,21 +2440,27 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkAttachmentDescription*)(toCount->pAttachments + i), count);
+ count_VkAttachmentDescription(featureBits, rootType, (const VkAttachmentDescription*)(toCount->pAttachments + i), count);
}
}
*count += sizeof(uint32_t);
@@ -2105,7 +2468,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->subpassCount; ++i)
{
- count_VkSubpassDescription(featureBits, (const VkSubpassDescription*)(toCount->pSubpasses + i), count);
+ count_VkSubpassDescription(featureBits, rootType, (const VkSubpassDescription*)(toCount->pSubpasses + i), count);
}
}
*count += sizeof(uint32_t);
@@ -2113,35 +2476,47 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->dependencyCount; ++i)
{
- count_VkSubpassDependency(featureBits, (const VkSubpassDependency*)(toCount->pDependencies + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkCommandPoolCreateFlags);
*count += sizeof(uint32_t);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkCommandBufferLevel);
@@ -2150,14 +2525,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -2170,29 +2551,37 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkCommandBufferInheritanceInfo*)(toCount->pInheritanceInfo), count);
+ count_VkCommandBufferInheritanceInfo(featureBits, rootType, (const VkCommandBufferInheritanceInfo*)(toCount->pInheritanceInfo), count);
}
}
void count_VkBufferCopy(
uint32_t featureBits,
+ VkStructureType rootType,
const VkBufferCopy* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceSize);
@@ -2202,10 +2591,12 @@
void count_VkImageSubresourceLayers(
uint32_t featureBits,
+ VkStructureType rootType,
const VkImageSubresourceLayers* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkImageAspectFlags);
@@ -2216,26 +2607,30 @@
void count_VkBufferImageCopy(
uint32_t featureBits,
+ VkStructureType rootType,
const VkBufferImageCopy* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceSize);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->imageOffset), count);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->imageExtent), 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += 4 * sizeof(float);
@@ -2243,10 +2638,12 @@
void count_VkClearDepthStencilValue(
uint32_t featureBits,
+ VkStructureType rootType,
const VkClearDepthStencilValue* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(float);
@@ -2255,106 +2652,124 @@
void count_VkClearValue(
uint32_t featureBits,
+ VkStructureType rootType,
const VkClearValue* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
- count_VkClearColorValue(featureBits, (VkClearColorValue*)(&toCount->color), count);
+ count_VkClearColorValue(featureBits, rootType, (VkClearColorValue*)(&toCount->color), count);
}
void count_VkClearAttachment(
uint32_t featureBits,
+ VkStructureType rootType,
const VkClearAttachment* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkImageAspectFlags);
*count += sizeof(uint32_t);
- count_VkClearValue(featureBits, (VkClearValue*)(&toCount->clearValue), count);
+ count_VkClearValue(featureBits, rootType, (VkClearValue*)(&toCount->clearValue), count);
}
void count_VkClearRect(
uint32_t featureBits,
+ VkStructureType rootType,
const VkClearRect* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
- count_VkRect2D(featureBits, (VkRect2D*)(&toCount->rect), count);
+ count_VkRect2D(featureBits, rootType, (VkRect2D*)(&toCount->rect), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
}
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, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- count_VkOffset3D(featureBits, (VkOffset3D*)(toCount->srcOffsets + i), count);
+ count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->srcOffsets + i), count);
}
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- count_VkOffset3D(featureBits, (VkOffset3D*)(toCount->dstOffsets + i), count);
+ count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->dstOffsets + i), 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, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->srcOffset), count);
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->dstOffset), count);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->extent), 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_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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->srcOffset), count);
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->dstOffset), count);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->extent), 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_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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
*count += 1 * 8;
- count_VkRect2D(featureBits, (VkRect2D*)(&toCount->renderArea), count);
+ count_VkRect2D(featureBits, rootType, (VkRect2D*)(&toCount->renderArea), count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
@@ -2364,7 +2779,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->clearValueCount; ++i)
{
- count_VkClearValue(featureBits, (const VkClearValue*)(toCount->pClearValues + i), count);
+ count_VkClearValue(featureBits, rootType, (const VkClearValue*)(toCount->pClearValues + i), count);
}
}
}
@@ -2374,14 +2789,20 @@
#ifdef VK_VERSION_1_1
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(VkShaderStageFlags);
*count += sizeof(VkSubgroupFeatureFlags);
@@ -2390,14 +2811,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
@@ -2407,14 +2834,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
@@ -2424,14 +2857,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -2440,28 +2879,40 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
@@ -2470,62 +2921,86 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkMemoryAllocateFlags);
*count += sizeof(uint32_t);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkRect2D*)(toCount->pDeviceRenderAreas + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -2545,28 +3020,40 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -2576,14 +3063,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -2594,21 +3087,27 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->splitInstanceBindRegionCount; ++i)
{
- count_VkRect2D(featureBits, (const VkRect2D*)(toCount->pSplitInstanceBindRegions + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice);
*count += sizeof(VkBool32);
@@ -2616,14 +3115,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -2633,134 +3138,194 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkMemoryRequirements(featureBits, (VkMemoryRequirements*)(&toCount->memoryRequirements), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkSparseImageMemoryRequirements(featureBits, (VkSparseImageMemoryRequirements*)(&toCount->memoryRequirements), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkPhysicalDeviceFeatures(featureBits, (VkPhysicalDeviceFeatures*)(&toCount->features), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkPhysicalDeviceProperties(featureBits, (VkPhysicalDeviceProperties*)(&toCount->properties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkFormatProperties(featureBits, (VkFormatProperties*)(&toCount->formatProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkImageFormatProperties(featureBits, (VkImageFormatProperties*)(&toCount->imageFormatProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
*count += sizeof(VkImageType);
*count += sizeof(VkImageTiling);
@@ -2770,53 +3335,77 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkQueueFamilyProperties(featureBits, (VkQueueFamilyProperties*)(&toCount->queueFamilyProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkPhysicalDeviceMemoryProperties(featureBits, (VkPhysicalDeviceMemoryProperties*)(&toCount->memoryProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkSparseImageFormatProperties(featureBits, (VkSparseImageFormatProperties*)(&toCount->properties), count);
+ 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);
}
void count_VkPhysicalDeviceSparseImageFormatInfo2(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseImageFormatInfo2* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
*count += sizeof(VkImageType);
*count += sizeof(VkSampleCountFlagBits);
@@ -2826,23 +3415,31 @@
void count_VkPhysicalDevicePointClippingProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePointClippingProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -2852,60 +3449,84 @@
void count_VkRenderPassInputAttachmentAspectCreateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkInputAttachmentAspectReference*)(toCount->pAspectReferences + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageUsageFlags);
}
void count_VkPipelineTessellationDomainOriginStateCreateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -2925,14 +3546,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -2940,68 +3567,98 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
}
void count_VkPhysicalDeviceVariablePointersFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceProtectedMemoryFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceProtectedMemoryProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -3009,31 +3666,43 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (VkComponentMapping*)(&toCount->components), count);
+ count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components), count);
*count += sizeof(VkChromaLocation);
*count += sizeof(VkChromaLocation);
*count += sizeof(VkFilter);
@@ -3042,76 +3711,108 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageAspectFlagBits);
}
void count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkSamplerYcbcrConversionImageFormatProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -3124,21 +3825,27 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkDescriptorUpdateTemplateEntry*)(toCount->pDescriptorUpdateEntries + i), count);
+ count_VkDescriptorUpdateTemplateEntry(featureBits, rootType, (const VkDescriptorUpdateTemplateEntry*)(toCount->pDescriptorUpdateEntries + i), count);
}
}
*count += sizeof(VkDescriptorUpdateTemplateType);
@@ -3152,10 +3859,12 @@
void count_VkExternalMemoryProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkExternalMemoryProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkExternalMemoryFeatureFlags);
@@ -3165,40 +3874,58 @@
void count_VkPhysicalDeviceExternalImageFormatInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalImageFormatInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkExternalMemoryProperties(featureBits, (VkExternalMemoryProperties*)(&toCount->externalMemoryProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBufferCreateFlags);
*count += sizeof(VkBufferUsageFlags);
*count += sizeof(VkExternalMemoryHandleTypeFlagBits);
@@ -3206,27 +3933,39 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkExternalMemoryProperties(featureBits, (VkExternalMemoryProperties*)(&toCount->externalMemoryProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += VK_UUID_SIZE * sizeof(uint8_t);
*count += VK_UUID_SIZE * sizeof(uint8_t);
*count += VK_LUID_SIZE * sizeof(uint8_t);
@@ -3236,66 +3975,96 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalFenceHandleTypeFlags);
*count += sizeof(VkExternalFenceHandleTypeFlags);
*count += sizeof(VkExternalFenceFeatureFlags);
@@ -3303,53 +4072,77 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalSemaphoreHandleTypeFlags);
}
void count_VkPhysicalDeviceExternalSemaphoreInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalSemaphoreInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalSemaphoreHandleTypeFlags);
*count += sizeof(VkExternalSemaphoreHandleTypeFlags);
*count += sizeof(VkExternalSemaphoreFeatureFlags);
@@ -3357,41 +4150,59 @@
void count_VkPhysicalDeviceMaintenance3Properties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceMaintenance3Properties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(VkDeviceSize);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceShaderDrawParametersFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -3399,14 +4210,20 @@
#ifdef VK_VERSION_1_2
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -3423,14 +4240,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += VK_UUID_SIZE * sizeof(uint8_t);
*count += VK_UUID_SIZE * sizeof(uint8_t);
*count += VK_LUID_SIZE * sizeof(uint8_t);
@@ -3450,14 +4273,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -3509,10 +4338,12 @@
void count_VkConformanceVersion(
uint32_t featureBits,
+ VkStructureType rootType,
const VkConformanceVersion* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint8_t);
@@ -3523,18 +4354,24 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (VkConformanceVersion*)(&toCount->conformanceVersion), count);
+ count_VkConformanceVersion(featureBits, rootType, (VkConformanceVersion*)(&toCount->conformanceVersion), count);
*count += sizeof(VkShaderFloatControlsIndependence);
*count += sizeof(VkShaderFloatControlsIndependence);
*count += sizeof(VkBool32);
@@ -3587,14 +4424,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -3604,14 +4447,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAttachmentDescriptionFlags);
*count += sizeof(VkFormat);
*count += sizeof(VkSampleCountFlagBits);
@@ -3625,14 +4474,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(VkImageLayout);
*count += sizeof(VkImageAspectFlags);
@@ -3640,14 +4495,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSubpassDescriptionFlags);
*count += sizeof(VkPipelineBindPoint);
*count += sizeof(uint32_t);
@@ -3656,7 +4517,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->inputAttachmentCount; ++i)
{
- count_VkAttachmentReference2(featureBits, (const VkAttachmentReference2*)(toCount->pInputAttachments + i), count);
+ count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pInputAttachments + i), count);
}
}
*count += sizeof(uint32_t);
@@ -3664,7 +4525,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
{
- count_VkAttachmentReference2(featureBits, (const VkAttachmentReference2*)(toCount->pColorAttachments + i), count);
+ count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pColorAttachments + i), count);
}
}
// WARNING PTR CHECK
@@ -3675,7 +4536,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
{
- count_VkAttachmentReference2(featureBits, (const VkAttachmentReference2*)(toCount->pResolveAttachments + i), count);
+ count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pResolveAttachments + i), count);
}
}
}
@@ -3683,7 +4544,7 @@
*count += 8;
if (toCount->pDepthStencilAttachment)
{
- count_VkAttachmentReference2(featureBits, (const VkAttachmentReference2*)(toCount->pDepthStencilAttachment), count);
+ count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pDepthStencilAttachment), count);
}
*count += sizeof(uint32_t);
if (toCount)
@@ -3694,14 +4555,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(VkPipelineStageFlags);
@@ -3714,21 +4581,27 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkAttachmentDescription2*)(toCount->pAttachments + i), count);
+ count_VkAttachmentDescription2(featureBits, rootType, (const VkAttachmentDescription2*)(toCount->pAttachments + i), count);
}
}
*count += sizeof(uint32_t);
@@ -3736,7 +4609,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->subpassCount; ++i)
{
- count_VkSubpassDescription2(featureBits, (const VkSubpassDescription2*)(toCount->pSubpasses + i), count);
+ count_VkSubpassDescription2(featureBits, rootType, (const VkSubpassDescription2*)(toCount->pSubpasses + i), count);
}
}
*count += sizeof(uint32_t);
@@ -3744,7 +4617,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->dependencyCount; ++i)
{
- count_VkSubpassDependency2(featureBits, (const VkSubpassDependency2*)(toCount->pDependencies + i), count);
+ count_VkSubpassDependency2(featureBits, rootType, (const VkSubpassDependency2*)(toCount->pDependencies + i), count);
}
}
*count += sizeof(uint32_t);
@@ -3756,39 +4629,57 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -3796,58 +4687,82 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceShaderFloat16Int8Features(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceFloatControlsProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFloatControlsProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkShaderFloatControlsIndependence);
*count += sizeof(VkShaderFloatControlsIndependence);
*count += sizeof(VkBool32);
@@ -3869,14 +4784,20 @@
void count_VkDescriptorSetLayoutBindingFlagsCreateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -3891,14 +4812,20 @@
void count_VkPhysicalDeviceDescriptorIndexingFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -3923,14 +4850,20 @@
void count_VkPhysicalDeviceDescriptorIndexingProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -3958,14 +4891,20 @@
void count_VkDescriptorSetVariableDescriptorCountAllocateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -3975,47 +4914,65 @@
void count_VkDescriptorSetVariableDescriptorCountLayoutSupport(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
void count_VkSubpassDescriptionDepthStencilResolve(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSubpassDescriptionDepthStencilResolve* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkResolveModeFlagBits);
*count += sizeof(VkResolveModeFlagBits);
// WARNING PTR CHECK
*count += 8;
if (toCount->pDepthStencilResolveAttachment)
{
- count_VkAttachmentReference2(featureBits, (const VkAttachmentReference2*)(toCount->pDepthStencilResolveAttachment), count);
+ count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pDepthStencilResolveAttachment), count);
}
}
void count_VkPhysicalDeviceDepthStencilResolveProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkResolveModeFlags);
*count += sizeof(VkResolveModeFlags);
*count += sizeof(VkBool32);
@@ -4024,67 +4981,97 @@
void count_VkPhysicalDeviceScalarBlockLayoutFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSamplerReductionMode);
}
void count_VkPhysicalDeviceSamplerFilterMinmaxProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceVulkanMemoryModelFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -4092,27 +5079,39 @@
void count_VkPhysicalDeviceImagelessFramebufferFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageCreateFlags);
*count += sizeof(VkImageUsageFlags);
*count += sizeof(uint32_t);
@@ -4127,34 +5126,46 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkFramebufferAttachmentImageInfo*)(toCount->pAttachmentImageInfos + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -4164,133 +5175,193 @@
void count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageLayout);
*count += sizeof(VkImageLayout);
}
void count_VkPhysicalDeviceHostQueryResetFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceHostQueryResetFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceTimelineSemaphoreFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceTimelineSemaphoreProperties(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSemaphoreType);
*count += sizeof(uint64_t);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -4315,14 +5386,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -4337,14 +5414,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(uint64_t);
@@ -4352,14 +5435,20 @@
void count_VkPhysicalDeviceBufferDeviceAddressFeatures(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -4367,54 +5456,78 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
void count_VkBufferOpaqueCaptureAddressCreateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkBufferOpaqueCaptureAddressCreateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
}
void count_VkMemoryOpaqueCaptureAddressAllocateInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
}
void count_VkDeviceMemoryOpaqueCaptureAddressInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
@@ -4423,17 +5536,19 @@
#ifdef VK_KHR_surface
void count_VkSurfaceCapabilitiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->currentExtent), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->minImageExtent), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->maxImageExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->currentExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minImageExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxImageExtent), count);
*count += sizeof(uint32_t);
*count += sizeof(VkSurfaceTransformFlagsKHR);
*count += sizeof(VkSurfaceTransformFlagBitsKHR);
@@ -4443,10 +5558,12 @@
void count_VkSurfaceFormatKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSurfaceFormatKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkFormat);
@@ -4457,21 +5574,27 @@
#ifdef VK_KHR_swapchain
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSwapchainCreateFlagsKHR);
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(uint32_t);
*count += sizeof(VkFormat);
*count += sizeof(VkColorSpaceKHR);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->imageExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->imageExtent), count);
*count += sizeof(uint32_t);
*count += sizeof(VkImageUsageFlags);
*count += sizeof(VkSharingMode);
@@ -4495,14 +5618,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -4530,28 +5659,40 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -4559,14 +5700,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(uint64_t);
@@ -4579,28 +5726,40 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t);
*count += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -4611,14 +5770,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
@@ -4626,68 +5791,82 @@
#ifdef VK_KHR_display
void count_VkDisplayModeParametersKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDisplayModeParametersKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->visibleRegion), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->visibleRegion), count);
*count += sizeof(uint32_t);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDisplayModeCreateFlagsKHR);
- count_VkDisplayModeParametersKHR(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
*count += 1 * 8;
- count_VkDisplayModeParametersKHR(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDisplayPlaneAlphaFlagsKHR);
- count_VkOffset2D(featureBits, (VkOffset2D*)(&toCount->minSrcPosition), count);
- count_VkOffset2D(featureBits, (VkOffset2D*)(&toCount->maxSrcPosition), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->minSrcExtent), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->maxSrcExtent), count);
- count_VkOffset2D(featureBits, (VkOffset2D*)(&toCount->minDstPosition), count);
- count_VkOffset2D(featureBits, (VkOffset2D*)(&toCount->maxDstPosition), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->minDstExtent), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->maxDstExtent), count);
+ count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->minSrcPosition), count);
+ count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->maxSrcPosition), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minSrcExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxSrcExtent), count);
+ count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->minDstPosition), count);
+ count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->maxDstPosition), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minDstExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxDstExtent), count);
}
void count_VkDisplayPlanePropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDisplayPlanePropertiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
@@ -4697,17 +5876,19 @@
void count_VkDisplayPropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDisplayPropertiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(uint32_t) + (toCount->displayName ? strlen(toCount->displayName) : 0);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->physicalDimensions), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->physicalResolution), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->physicalDimensions), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->physicalResolution), count);
*count += sizeof(VkSurfaceTransformFlagsKHR);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -4715,14 +5896,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDisplaySurfaceCreateFlagsKHR);
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -4731,23 +5918,29 @@
*count += sizeof(VkSurfaceTransformFlagBitsKHR);
*count += sizeof(float);
*count += sizeof(VkDisplayPlaneAlphaFlagBitsKHR);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->imageExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->imageExtent), count);
}
#endif
#ifdef VK_KHR_display_swapchain
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkRect2D(featureBits, (VkRect2D*)(&toCount->srcRect), count);
- count_VkRect2D(featureBits, (VkRect2D*)(&toCount->dstRect), count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ count_VkRect2D(featureBits, rootType, (VkRect2D*)(&toCount->srcRect), count);
+ count_VkRect2D(featureBits, rootType, (VkRect2D*)(&toCount->dstRect), count);
*count += sizeof(VkBool32);
}
@@ -4755,14 +5948,20 @@
#ifdef VK_KHR_xlib_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -4777,14 +5976,20 @@
#ifdef VK_KHR_xcb_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -4799,14 +6004,20 @@
#ifdef VK_KHR_wayland_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -4826,14 +6037,20 @@
#ifdef VK_KHR_android_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -4847,14 +6064,20 @@
#ifdef VK_KHR_win32_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkWin32SurfaceCreateFlagsKHR);
*count += sizeof(HINSTANCE);
*count += sizeof(HWND);
@@ -4882,14 +6105,20 @@
#ifdef VK_KHR_external_memory_win32
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlagBits);
*count += sizeof(HANDLE);
*count += sizeof(LPCWSTR);
@@ -4897,14 +6126,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -4917,27 +6152,39 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkExternalMemoryHandleTypeFlagBits);
@@ -4947,41 +6194,59 @@
#ifdef VK_KHR_external_memory_fd
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlagBits);
*count += sizeof(int);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkExternalMemoryHandleTypeFlagBits);
@@ -4991,14 +6256,20 @@
#ifdef VK_KHR_win32_keyed_mutex
void count_VkWin32KeyedMutexAcquireReleaseInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -5031,14 +6302,20 @@
#ifdef VK_KHR_external_semaphore_win32
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkSemaphoreImportFlags);
@@ -5049,14 +6326,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -5069,14 +6352,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -5101,14 +6390,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkExternalSemaphoreHandleTypeFlagBits);
@@ -5118,14 +6413,20 @@
#ifdef VK_KHR_external_semaphore_fd
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkSemaphoreImportFlags);
@@ -5135,14 +6436,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkExternalSemaphoreHandleTypeFlagBits);
@@ -5152,14 +6459,20 @@
#ifdef VK_KHR_push_descriptor
void count_VkPhysicalDevicePushDescriptorPropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
@@ -5171,23 +6484,27 @@
#ifdef VK_KHR_incremental_present
void count_VkRectLayerKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkRectLayerKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
- count_VkOffset2D(featureBits, (VkOffset2D*)(&toCount->offset), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->extent), count);
+ count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->offset), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->extent), count);
*count += sizeof(uint32_t);
}
void count_VkPresentRegionKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPresentRegionKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -5199,7 +6516,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->rectangleCount; ++i)
{
- count_VkRectLayerKHR(featureBits, (const VkRectLayerKHR*)(toCount->pRectangles + i), count);
+ count_VkRectLayerKHR(featureBits, rootType, (const VkRectLayerKHR*)(toCount->pRectangles + i), count);
}
}
}
@@ -5207,14 +6524,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -5224,7 +6547,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->swapchainCount; ++i)
{
- count_VkPresentRegionKHR(featureBits, (const VkPresentRegionKHR*)(toCount->pRegions + i), count);
+ count_VkPresentRegionKHR(featureBits, rootType, (const VkPresentRegionKHR*)(toCount->pRegions + i), count);
}
}
}
@@ -5240,14 +6563,20 @@
#ifdef VK_KHR_shared_presentable_image
void count_VkSharedPresentSurfaceCapabilitiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageUsageFlags);
}
@@ -5259,14 +6588,20 @@
#ifdef VK_KHR_external_fence_win32
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkFenceImportFlags);
@@ -5277,14 +6612,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -5297,14 +6638,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkExternalFenceHandleTypeFlagBits);
@@ -5314,14 +6661,20 @@
#ifdef VK_KHR_external_fence_fd
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkFenceImportFlags);
@@ -5331,14 +6684,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkExternalFenceHandleTypeFlagBits);
@@ -5348,41 +6707,59 @@
#ifdef VK_KHR_performance_query
void count_VkPhysicalDevicePerformanceQueryFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDevicePerformanceQueryPropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPerformanceCounterUnitKHR);
*count += sizeof(VkPerformanceCounterScopeKHR);
*count += sizeof(VkPerformanceCounterStorageKHR);
@@ -5391,14 +6768,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPerformanceCounterDescriptionFlagsKHR);
*count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
*count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
@@ -5407,14 +6790,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -5425,10 +6814,12 @@
void count_VkPerformanceCounterResultKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPerformanceCounterResultKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(int32_t);
@@ -5436,28 +6827,40 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAcquireProfilingLockFlagsKHR);
*count += sizeof(uint64_t);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
@@ -5467,42 +6870,60 @@
#ifdef VK_KHR_get_surface_capabilities2
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkSurfaceCapabilitiesKHR(featureBits, (VkSurfaceCapabilitiesKHR*)(&toCount->surfaceCapabilities), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkSurfaceFormatKHR(featureBits, (VkSurfaceFormatKHR*)(&toCount->surfaceFormat), count);
+ 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);
}
#endif
@@ -5511,53 +6932,77 @@
#ifdef VK_KHR_get_display_properties2
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkDisplayPropertiesKHR(featureBits, (VkDisplayPropertiesKHR*)(&toCount->displayProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkDisplayPlanePropertiesKHR(featureBits, (VkDisplayPlanePropertiesKHR*)(&toCount->displayPlaneProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkDisplayModePropertiesKHR(featureBits, (VkDisplayModePropertiesKHR*)(&toCount->displayModeProperties), count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -5565,15 +7010,21 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkDisplayPlaneCapabilitiesKHR(featureBits, (VkDisplayPlaneCapabilitiesKHR*)(&toCount->capabilities), count);
+ 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);
}
#endif
@@ -5594,14 +7045,20 @@
#ifdef VK_KHR_portability_subset
void count_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -5621,14 +7078,20 @@
void count_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
@@ -5646,14 +7109,20 @@
#ifdef VK_KHR_shader_clock
void count_VkPhysicalDeviceShaderClockFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
@@ -5674,14 +7143,20 @@
#ifdef VK_KHR_shader_terminate_invocation
void count_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -5689,42 +7164,60 @@
#ifdef VK_KHR_fragment_shading_rate
void count_VkFragmentShadingRateAttachmentInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkFragmentShadingRateAttachmentInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkAttachmentReference2(featureBits, (const VkAttachmentReference2*)(toCount->pFragmentShadingRateAttachment), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->shadingRateAttachmentTexelSize), count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pFragmentShadingRateAttachment), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->shadingRateAttachmentTexelSize), count);
}
void count_VkPipelineFragmentShadingRateStateCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->fragmentSize), count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->fragmentSize), count);
*count += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
}
void count_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -5732,21 +7225,27 @@
void count_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->minFragmentShadingRateAttachmentTexelSize), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->maxFragmentShadingRateAttachmentTexelSize), count);
+ 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 += sizeof(uint32_t);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->maxFragmentSize), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxFragmentSize), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(VkSampleCountFlagBits);
@@ -5761,16 +7260,22 @@
void count_VkPhysicalDeviceFragmentShadingRateKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSampleCountFlags);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->fragmentSize), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->fragmentSize), count);
}
#endif
@@ -5779,14 +7284,20 @@
#ifdef VK_KHR_surface_protected_capabilities
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -5802,41 +7313,59 @@
#ifdef VK_KHR_pipeline_executable_properties
void count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkShaderStageFlags);
*count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
*count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
@@ -5845,14 +7374,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -5860,10 +7395,12 @@
void count_VkPipelineExecutableStatisticValueKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticValueKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkBool32);
@@ -5871,30 +7408,42 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkBool32);
@@ -5914,14 +7463,20 @@
#ifdef VK_KHR_pipeline_library
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -5935,14 +7490,20 @@
#ifdef VK_KHR_copy_commands2
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
@@ -5950,14 +7511,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
@@ -5967,38 +7534,50 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
{
- count_VkBufferCopy2KHR(featureBits, (const VkBufferCopy2KHR*)(toCount->pRegions + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->srcOffset), count);
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->dstOffset), count);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->extent), count);
+ 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_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -6010,39 +7589,51 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
{
- count_VkImageCopy2KHR(featureBits, (const VkImageCopy2KHR*)(toCount->pRegions + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->imageOffset), count);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->imageExtent), 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
@@ -6053,21 +7644,27 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
{
- count_VkBufferImageCopy2KHR(featureBits, (const VkBufferImageCopy2KHR*)(toCount->pRegions + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -6078,43 +7675,55 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
{
- count_VkBufferImageCopy2KHR(featureBits, (const VkBufferImageCopy2KHR*)(toCount->pRegions + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
{
- count_VkOffset3D(featureBits, (VkOffset3D*)(toCount->srcOffsets + i), count);
+ rootType = toCount->sType;
}
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
+ 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_VkOffset3D(featureBits, (VkOffset3D*)(toCount->dstOffsets + i), count);
+ 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_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->dstOffsets + i), 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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -6126,7 +7735,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
{
- count_VkImageBlit2KHR(featureBits, (const VkImageBlit2KHR*)(toCount->pRegions + i), count);
+ count_VkImageBlit2KHR(featureBits, rootType, (const VkImageBlit2KHR*)(toCount->pRegions + i), count);
}
}
*count += sizeof(VkFilter);
@@ -6134,31 +7743,43 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->srcOffset), count);
- count_VkImageSubresourceLayers(featureBits, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
- count_VkOffset3D(featureBits, (VkOffset3D*)(&toCount->dstOffset), count);
- count_VkExtent3D(featureBits, (VkExtent3D*)(&toCount->extent), count);
+ 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_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -6170,7 +7791,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
{
- count_VkImageResolve2KHR(featureBits, (const VkImageResolve2KHR*)(toCount->pRegions + i), count);
+ count_VkImageResolve2KHR(featureBits, rootType, (const VkImageResolve2KHR*)(toCount->pRegions + i), count);
}
}
}
@@ -6179,14 +7800,20 @@
#ifdef VK_ANDROID_native_buffer
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -6204,14 +7831,20 @@
#ifdef VK_EXT_debug_report
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDebugReportFlagsEXT);
*count += 8;
// WARNING PTR CHECK
@@ -6232,14 +7865,20 @@
#ifdef VK_AMD_rasterization_order
void count_VkPipelineRasterizationStateRasterizationOrderAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkRasterizationOrderAMD);
}
@@ -6251,14 +7890,20 @@
#ifdef VK_EXT_debug_marker
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDebugReportObjectTypeEXT);
*count += sizeof(uint64_t);
*count += sizeof(uint32_t) + (toCount->pObjectName ? strlen(toCount->pObjectName) : 0);
@@ -6266,14 +7911,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDebugReportObjectTypeEXT);
*count += sizeof(uint64_t);
*count += sizeof(uint64_t);
@@ -6286,14 +7937,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t) + (toCount->pMarkerName ? strlen(toCount->pMarkerName) : 0);
*count += 4 * sizeof(float);
}
@@ -6304,40 +7961,58 @@
#ifdef VK_NV_dedicated_allocation
void count_VkDedicatedAllocationImageCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDedicatedAllocationImageCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkDedicatedAllocationBufferCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDedicatedAllocationBufferCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkDedicatedAllocationMemoryAllocateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
@@ -6348,28 +8023,40 @@
#ifdef VK_EXT_transform_feedback
void count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(VkDeviceSize);
@@ -6384,14 +8071,20 @@
void count_VkPipelineRasterizationStateStreamCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT);
*count += sizeof(uint32_t);
}
@@ -6400,14 +8093,20 @@
#ifdef VK_NVX_image_view_handle
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkDescriptorType);
@@ -6417,14 +8116,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceAddress);
*count += sizeof(VkDeviceSize);
}
@@ -6441,14 +8146,20 @@
#ifdef VK_AMD_texture_gather_bias_lod
void count_VkTextureLODGatherFormatPropertiesAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -6456,10 +8167,12 @@
#ifdef VK_AMD_shader_info
void count_VkShaderResourceUsageAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkShaderResourceUsageAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -6471,14 +8184,16 @@
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, (VkShaderResourceUsageAMD*)(&toCount->resourceUsage), count);
+ count_VkShaderResourceUsageAMD(featureBits, rootType, (VkShaderResourceUsageAMD*)(&toCount->resourceUsage), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -6492,14 +8207,20 @@
#ifdef VK_GGP_stream_descriptor_surface
void count_VkStreamDescriptorSurfaceCreateInfoGGP(
uint32_t featureBits,
+ VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP);
*count += sizeof(GgpStreamDescriptor);
}
@@ -6508,14 +8229,20 @@
#ifdef VK_NV_corner_sampled_image
void count_VkPhysicalDeviceCornerSampledImageFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -6525,13 +8252,15 @@
#ifdef VK_NV_external_memory_capabilities
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, (VkImageFormatProperties*)(&toCount->imageFormatProperties), count);
+ count_VkImageFormatProperties(featureBits, rootType, (VkImageFormatProperties*)(&toCount->imageFormatProperties), count);
*count += sizeof(VkExternalMemoryFeatureFlagsNV);
*count += sizeof(VkExternalMemoryHandleTypeFlagsNV);
*count += sizeof(VkExternalMemoryHandleTypeFlagsNV);
@@ -6541,27 +8270,39 @@
#ifdef VK_NV_external_memory
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}
@@ -6569,28 +8310,40 @@
#ifdef VK_NV_external_memory_win32
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlagsNV);
*count += sizeof(HANDLE);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -6604,14 +8357,20 @@
#ifdef VK_NV_win32_keyed_mutex
void count_VkWin32KeyedMutexAcquireReleaseInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -6640,14 +8399,20 @@
#ifdef VK_EXT_validation_flags
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -6659,14 +8424,20 @@
#ifdef VK_NN_vi_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -6684,14 +8455,20 @@
#ifdef VK_EXT_texture_compression_astc_hdr
void count_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -6699,27 +8476,39 @@
#ifdef VK_EXT_astc_decode_mode
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
}
void count_VkPhysicalDeviceASTCDecodeFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceASTCDecodeFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -6727,14 +8516,20 @@
#ifdef VK_EXT_conditional_rendering
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkDeviceSize);
@@ -6743,28 +8538,40 @@
void count_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -6772,10 +8579,12 @@
#ifdef VK_NV_clip_space_w_scaling
void count_VkViewportWScalingNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkViewportWScalingNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(float);
@@ -6784,14 +8593,20 @@
void count_VkPipelineViewportWScalingStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineViewportWScalingStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -6802,7 +8617,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i)
{
- count_VkViewportWScalingNV(featureBits, (const VkViewportWScalingNV*)(toCount->pViewportWScalings + i), count);
+ count_VkViewportWScalingNV(featureBits, rootType, (const VkViewportWScalingNV*)(toCount->pViewportWScalings + i), count);
}
}
}
@@ -6816,19 +8631,25 @@
#ifdef VK_EXT_display_surface_counter
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->currentExtent), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->minImageExtent), count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->maxImageExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->currentExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minImageExtent), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxImageExtent), count);
*count += sizeof(uint32_t);
*count += sizeof(VkSurfaceTransformFlagsKHR);
*count += sizeof(VkSurfaceTransformFlagBitsKHR);
@@ -6841,53 +8662,77 @@
#ifdef VK_EXT_display_control
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSurfaceCounterFlagsEXT);
}
@@ -6895,10 +8740,12 @@
#ifdef VK_GOOGLE_display_timing
void count_VkRefreshCycleDurationGOOGLE(
uint32_t featureBits,
+ VkStructureType rootType,
const VkRefreshCycleDurationGOOGLE* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint64_t);
@@ -6906,10 +8753,12 @@
void count_VkPastPresentationTimingGOOGLE(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPastPresentationTimingGOOGLE* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -6921,10 +8770,12 @@
void count_VkPresentTimeGOOGLE(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPresentTimeGOOGLE* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -6933,14 +8784,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -6950,7 +8807,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->swapchainCount; ++i)
{
- count_VkPresentTimeGOOGLE(featureBits, (const VkPresentTimeGOOGLE*)(toCount->pTimes + i), count);
+ count_VkPresentTimeGOOGLE(featureBits, rootType, (const VkPresentTimeGOOGLE*)(toCount->pTimes + i), count);
}
}
}
@@ -6966,14 +8823,20 @@
#ifdef VK_NVX_multiview_per_view_attributes
void count_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -6981,10 +8844,12 @@
#ifdef VK_NV_viewport_swizzle
void count_VkViewportSwizzleNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkViewportSwizzleNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkViewportCoordinateSwizzleNV);
@@ -6995,14 +8860,20 @@
void count_VkPipelineViewportSwizzleStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -7013,7 +8884,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i)
{
- count_VkViewportSwizzleNV(featureBits, (const VkViewportSwizzleNV*)(toCount->pViewportSwizzles + i), count);
+ count_VkViewportSwizzleNV(featureBits, rootType, (const VkViewportSwizzleNV*)(toCount->pViewportSwizzles + i), count);
}
}
}
@@ -7023,27 +8894,39 @@
#ifdef VK_EXT_discard_rectangles
void count_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
void count_VkPipelineDiscardRectangleStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT);
*count += sizeof(VkDiscardRectangleModeEXT);
*count += sizeof(uint32_t);
@@ -7055,7 +8938,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->discardRectangleCount; ++i)
{
- count_VkRect2D(featureBits, (const VkRect2D*)(toCount->pDiscardRectangles + i), count);
+ count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pDiscardRectangles + i), count);
}
}
}
@@ -7065,14 +8948,20 @@
#ifdef VK_EXT_conservative_rasterization
void count_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(float);
*count += sizeof(float);
*count += sizeof(float);
@@ -7086,14 +8975,20 @@
void count_VkPipelineRasterizationConservativeStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT);
*count += sizeof(VkConservativeRasterizationModeEXT);
*count += sizeof(float);
@@ -7103,27 +8998,39 @@
#ifdef VK_EXT_depth_clip_enable
void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
*count += sizeof(VkBool32);
}
@@ -7134,10 +9041,12 @@
#ifdef VK_EXT_hdr_metadata
void count_VkXYColorEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkXYColorEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(float);
@@ -7146,18 +9055,24 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkXYColorEXT(featureBits, (VkXYColorEXT*)(&toCount->displayPrimaryRed), count);
- count_VkXYColorEXT(featureBits, (VkXYColorEXT*)(&toCount->displayPrimaryGreen), count);
- count_VkXYColorEXT(featureBits, (VkXYColorEXT*)(&toCount->displayPrimaryBlue), count);
- count_VkXYColorEXT(featureBits, (VkXYColorEXT*)(&toCount->whitePoint), count);
+ 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->displayPrimaryBlue), count);
+ count_VkXYColorEXT(featureBits, rootType, (VkXYColorEXT*)(&toCount->whitePoint), count);
*count += sizeof(float);
*count += sizeof(float);
*count += sizeof(float);
@@ -7168,14 +9083,20 @@
#ifdef VK_MVK_ios_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -7189,14 +9110,20 @@
#ifdef VK_MVK_macos_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -7216,28 +9143,40 @@
#ifdef VK_EXT_debug_utils
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t) + (toCount->pLabelName ? strlen(toCount->pLabelName) : 0);
*count += 4 * sizeof(float);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -7257,14 +9196,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
{
@@ -7290,7 +9235,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->queueLabelCount; ++i)
{
- count_VkDebugUtilsLabelEXT(featureBits, (VkDebugUtilsLabelEXT*)(toCount->pQueueLabels + i), count);
+ count_VkDebugUtilsLabelEXT(featureBits, rootType, (VkDebugUtilsLabelEXT*)(toCount->pQueueLabels + i), count);
}
}
}
@@ -7303,7 +9248,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->cmdBufLabelCount; ++i)
{
- count_VkDebugUtilsLabelEXT(featureBits, (VkDebugUtilsLabelEXT*)(toCount->pCmdBufLabels + i), count);
+ count_VkDebugUtilsLabelEXT(featureBits, rootType, (VkDebugUtilsLabelEXT*)(toCount->pCmdBufLabels + i), count);
}
}
}
@@ -7316,7 +9261,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->objectCount; ++i)
{
- count_VkDebugUtilsObjectNameInfoEXT(featureBits, (VkDebugUtilsObjectNameInfoEXT*)(toCount->pObjects + i), count);
+ count_VkDebugUtilsObjectNameInfoEXT(featureBits, rootType, (VkDebugUtilsObjectNameInfoEXT*)(toCount->pObjects + i), count);
}
}
}
@@ -7324,14 +9269,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDebugUtilsMessengerCreateFlagsEXT);
*count += sizeof(VkDebugUtilsMessageSeverityFlagsEXT);
*count += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
@@ -7346,14 +9297,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint64_t);
@@ -7368,45 +9325,63 @@
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
}
void count_VkAndroidHardwareBufferPropertiesANDROID(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
}
void count_VkAndroidHardwareBufferFormatPropertiesANDROID(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (VkComponentMapping*)(&toCount->samplerYcbcrConversionComponents), count);
+ count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->samplerYcbcrConversionComponents), count);
*count += sizeof(VkSamplerYcbcrModelConversion);
*count += sizeof(VkSamplerYcbcrRange);
*count += sizeof(VkChromaLocation);
@@ -7415,41 +9390,59 @@
void count_VkImportAndroidHardwareBufferInfoANDROID(
uint32_t featureBits,
+ VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(AHardwareBuffer);
}
void count_VkMemoryGetAndroidHardwareBufferInfoANDROID(
uint32_t featureBits,
+ VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
}
@@ -7465,28 +9458,40 @@
#ifdef VK_EXT_inline_uniform_block
void count_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint32_t);
@@ -7496,14 +9501,20 @@
void count_VkWriteDescriptorSetInlineUniformBlockEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -7513,14 +9524,20 @@
void count_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
@@ -7530,10 +9547,12 @@
#ifdef VK_EXT_sample_locations
void count_VkSampleLocationEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSampleLocationEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(float);
@@ -7542,66 +9561,82 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSampleCountFlagBits);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->sampleLocationGridSize), count);
+ 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, (const VkSampleLocationEXT*)(toCount->pSampleLocations + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
- count_VkSampleLocationsInfoEXT(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
- count_VkSampleLocationsInfoEXT(featureBits, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkAttachmentSampleLocationsEXT*)(toCount->pAttachmentInitialSampleLocations + i), count);
+ count_VkAttachmentSampleLocationsEXT(featureBits, rootType, (const VkAttachmentSampleLocationsEXT*)(toCount->pAttachmentInitialSampleLocations + i), count);
}
}
*count += sizeof(uint32_t);
@@ -7609,37 +9644,49 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->postSubpassSampleLocationsCount; ++i)
{
- count_VkSubpassSampleLocationsEXT(featureBits, (const VkSubpassSampleLocationsEXT*)(toCount->pPostSubpassSampleLocations + i), count);
+ count_VkSubpassSampleLocationsEXT(featureBits, rootType, (const VkSubpassSampleLocationsEXT*)(toCount->pPostSubpassSampleLocations + i), count);
}
}
}
void count_VkPipelineSampleLocationsStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
- count_VkSampleLocationsInfoEXT(featureBits, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSampleCountFlags);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->maxSampleLocationGridSize), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxSampleLocationGridSize), count);
*count += 2 * sizeof(float);
*count += sizeof(uint32_t);
*count += sizeof(VkBool32);
@@ -7647,42 +9694,60 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->maxSampleLocationGridSize), count);
+ 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);
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void count_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -7693,14 +9758,20 @@
void count_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBlendOverlapEXT);
@@ -7710,14 +9781,20 @@
#ifdef VK_NV_fragment_coverage_to_color
void count_VkPipelineCoverageToColorStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCoverageToColorStateCreateFlagsNV);
*count += sizeof(VkBool32);
*count += sizeof(uint32_t);
@@ -7727,14 +9804,20 @@
#ifdef VK_NV_framebuffer_mixed_samples
void count_VkPipelineCoverageModulationStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCoverageModulationStateCreateFlagsNV);
*count += sizeof(VkCoverageModulationModeNV);
*count += sizeof(VkBool32);
@@ -7756,28 +9839,40 @@
#ifdef VK_NV_shader_sm_builtins
void count_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
}
void count_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -7787,10 +9882,12 @@
#ifdef VK_EXT_image_drm_format_modifier
void count_VkDrmFormatModifierPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint64_t);
@@ -7800,14 +9897,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -7817,7 +9920,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->drmFormatModifierCount; ++i)
{
- count_VkDrmFormatModifierPropertiesEXT(featureBits, (VkDrmFormatModifierPropertiesEXT*)(toCount->pDrmFormatModifierProperties + i), count);
+ count_VkDrmFormatModifierPropertiesEXT(featureBits, rootType, (VkDrmFormatModifierPropertiesEXT*)(toCount->pDrmFormatModifierProperties + i), count);
}
}
}
@@ -7825,14 +9928,20 @@
void count_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
*count += sizeof(VkSharingMode);
*count += sizeof(uint32_t);
@@ -7849,14 +9958,20 @@
void count_VkImageDrmFormatModifierListCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -7866,35 +9981,47 @@
void count_VkImageDrmFormatModifierExplicitCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkSubresourceLayout*)(toCount->pPlaneLayouts + i), count);
+ count_VkSubresourceLayout(featureBits, rootType, (const VkSubresourceLayout*)(toCount->pPlaneLayouts + i), count);
}
}
}
void count_VkImageDrmFormatModifierPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkImageDrmFormatModifierPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
}
@@ -7902,14 +10029,20 @@
#ifdef VK_EXT_validation_cache
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -7920,14 +10053,20 @@
void count_VkShaderModuleValidationCacheCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
@@ -7940,10 +10079,12 @@
#ifdef VK_NV_shading_rate_image
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);
@@ -7955,14 +10096,20 @@
void count_VkPipelineViewportShadingRateImageStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -7973,7 +10120,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i)
{
- count_VkShadingRatePaletteNV(featureBits, (const VkShadingRatePaletteNV*)(toCount->pShadingRatePalettes + i), count);
+ count_VkShadingRatePaletteNV(featureBits, rootType, (const VkShadingRatePaletteNV*)(toCount->pShadingRatePalettes + i), count);
}
}
}
@@ -7981,39 +10128,53 @@
void count_VkPhysicalDeviceShadingRateImageFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceShadingRateImagePropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkExtent2D(featureBits, (VkExtent2D*)(&toCount->shadingRateTexelSize), count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->shadingRateTexelSize), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
}
void count_VkCoarseSampleLocationNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkCoarseSampleLocationNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -8023,10 +10184,12 @@
void count_VkCoarseSampleOrderCustomNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkCoarseSampleOrderCustomNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkShadingRatePaletteEntryNV);
@@ -8036,28 +10199,34 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->sampleLocationCount; ++i)
{
- count_VkCoarseSampleLocationNV(featureBits, (const VkCoarseSampleLocationNV*)(toCount->pSampleLocations + i), count);
+ count_VkCoarseSampleLocationNV(featureBits, rootType, (const VkCoarseSampleLocationNV*)(toCount->pSampleLocations + i), count);
}
}
}
void count_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkCoarseSampleOrderCustomNV*)(toCount->pCustomSampleOrders + i), count);
+ count_VkCoarseSampleOrderCustomNV(featureBits, rootType, (const VkCoarseSampleOrderCustomNV*)(toCount->pCustomSampleOrders + i), count);
}
}
}
@@ -8066,14 +10235,20 @@
#ifdef VK_NV_ray_tracing
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkRayTracingShaderGroupTypeKHR);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -8083,21 +10258,27 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
+ count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
}
}
*count += sizeof(uint32_t);
@@ -8105,7 +10286,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->groupCount; ++i)
{
- count_VkRayTracingShaderGroupCreateInfoNV(featureBits, (const VkRayTracingShaderGroupCreateInfoNV*)(toCount->pGroups + i), count);
+ count_VkRayTracingShaderGroupCreateInfoNV(featureBits, rootType, (const VkRayTracingShaderGroupCreateInfoNV*)(toCount->pGroups + i), count);
}
}
*count += sizeof(uint32_t);
@@ -8118,14 +10299,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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(VkDeviceSize);
@@ -8144,14 +10331,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -8161,41 +10354,55 @@
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, (VkGeometryTrianglesNV*)(&toCount->triangles), count);
- count_VkGeometryAABBNV(featureBits, (VkGeometryAABBNV*)(&toCount->aabbs), 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkGeometryTypeKHR);
- count_VkGeometryDataNV(featureBits, (VkGeometryDataNV*)(&toCount->geometry), count);
+ count_VkGeometryDataNV(featureBits, rootType, (VkGeometryDataNV*)(&toCount->geometry), count);
*count += sizeof(VkGeometryFlagsKHR);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAccelerationStructureTypeNV);
*count += sizeof(VkBuildAccelerationStructureFlagsNV);
*count += sizeof(uint32_t);
@@ -8204,35 +10411,47 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->geometryCount; ++i)
{
- count_VkGeometryNV(featureBits, (const VkGeometryNV*)(toCount->pGeometries + i), count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
- count_VkAccelerationStructureInfoNV(featureBits, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
@@ -8247,14 +10466,20 @@
void count_VkWriteDescriptorSetAccelerationStructureNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -8269,14 +10494,20 @@
void count_VkAccelerationStructureMemoryRequirementsInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAccelerationStructureMemoryRequirementsTypeNV);
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -8284,14 +10515,20 @@
void count_VkPhysicalDeviceRayTracingPropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPropertiesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint32_t);
@@ -8304,10 +10541,12 @@
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);
@@ -8315,10 +10554,12 @@
void count_VkAabbPositionsKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAabbPositionsKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(float);
@@ -8331,13 +10572,15 @@
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, (VkTransformMatrixKHR*)(&toCount->transform), count);
+ count_VkTransformMatrixKHR(featureBits, rootType, (VkTransformMatrixKHR*)(&toCount->transform), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -8349,27 +10592,39 @@
#ifdef VK_NV_representative_fragment_test
void count_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -8377,27 +10632,39 @@
#ifdef VK_EXT_filter_cubic
void count_VkPhysicalDeviceImageViewImageFormatInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageViewType);
}
void count_VkFilterCubicImageViewImageFormatPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
@@ -8408,14 +10675,20 @@
#ifdef VK_EXT_global_priority
void count_VkDeviceQueueGlobalPriorityCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkQueueGlobalPriorityEXT);
}
@@ -8423,14 +10696,20 @@
#ifdef VK_EXT_external_memory_host
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -8442,27 +10721,39 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
void count_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
}
@@ -8472,14 +10763,20 @@
#ifdef VK_AMD_pipeline_compiler_control
void count_VkPipelineCompilerControlCreateInfoAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCompilerControlFlagsAMD);
}
@@ -8487,14 +10784,20 @@
#ifdef VK_EXT_calibrated_timestamps
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkTimeDomainEXT);
}
@@ -8502,14 +10805,20 @@
#ifdef VK_AMD_shader_core_properties
void count_VkPhysicalDeviceShaderCorePropertiesAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint32_t);
@@ -8530,14 +10839,20 @@
#ifdef VK_AMD_memory_overallocation_behavior
void count_VkDeviceMemoryOverallocationCreateInfoAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkMemoryOverallocationBehaviorAMD);
}
@@ -8545,23 +10860,31 @@
#ifdef VK_EXT_vertex_attribute_divisor
void count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
void count_VkVertexInputBindingDivisorDescriptionEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -8570,34 +10893,46 @@
void count_VkPipelineVertexInputDivisorStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkVertexInputBindingDivisorDescriptionEXT*)(toCount->pVertexBindingDivisors + i), count);
+ count_VkVertexInputBindingDivisorDescriptionEXT(featureBits, rootType, (const VkVertexInputBindingDivisorDescriptionEXT*)(toCount->pVertexBindingDivisors + i), count);
}
}
}
void count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
@@ -8606,14 +10941,20 @@
#ifdef VK_GGP_frame_token
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(GgpFrameToken);
}
@@ -8621,10 +10962,12 @@
#ifdef VK_EXT_pipeline_creation_feedback
void count_VkPipelineCreationFeedbackEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkPipelineCreationFeedbackFlagsEXT);
@@ -8633,21 +10976,27 @@
void count_VkPipelineCreationFeedbackCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkPipelineCreationFeedbackEXT(featureBits, (VkPipelineCreationFeedbackEXT*)(toCount->pPipelineCreationFeedback), count);
+ 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 += sizeof(uint32_t);
if (toCount)
{
for (uint32_t i = 0; i < (uint32_t)toCount->pipelineStageCreationFeedbackCount; ++i)
{
- count_VkPipelineCreationFeedbackEXT(featureBits, (VkPipelineCreationFeedbackEXT*)(toCount->pPipelineStageCreationFeedbacks + i), count);
+ count_VkPipelineCreationFeedbackEXT(featureBits, rootType, (VkPipelineCreationFeedbackEXT*)(toCount->pPipelineStageCreationFeedbacks + i), count);
}
}
}
@@ -8658,14 +11007,20 @@
#ifdef VK_NV_compute_shader_derivatives
void count_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
@@ -8674,28 +11029,40 @@
#ifdef VK_NV_mesh_shader
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceMeshShaderPropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderPropertiesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += 3 * sizeof(uint32_t);
@@ -8713,10 +11080,12 @@
void count_VkDrawMeshTasksIndirectCommandNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDrawMeshTasksIndirectCommandNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -8727,14 +11096,20 @@
#ifdef VK_NV_fragment_shader_barycentric
void count_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -8742,14 +11117,20 @@
#ifdef VK_NV_shader_image_footprint
void count_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -8757,14 +11138,20 @@
#ifdef VK_NV_scissor_exclusive
void count_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -8774,7 +11161,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->exclusiveScissorCount; ++i)
{
- count_VkRect2D(featureBits, (const VkRect2D*)(toCount->pExclusiveScissors + i), count);
+ count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pExclusiveScissors + i), count);
}
}
}
@@ -8782,14 +11169,20 @@
void count_VkPhysicalDeviceExclusiveScissorFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -8797,27 +11190,39 @@
#ifdef VK_NV_device_diagnostic_checkpoints
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -8831,14 +11236,20 @@
#ifdef VK_INTEL_shader_integer_functions2
void count_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -8846,10 +11257,12 @@
#ifdef VK_INTEL_performance_query
void count_VkPerformanceValueDataINTEL(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPerformanceValueDataINTEL* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -8857,26 +11270,34 @@
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, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)
@@ -8887,53 +11308,77 @@
void count_VkQueryPoolPerformanceQueryCreateInfoINTEL(
uint32_t featureBits,
+ VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPerformanceOverrideTypeINTEL);
*count += sizeof(VkBool32);
*count += sizeof(uint64_t);
@@ -8941,14 +11386,20 @@
void count_VkPerformanceConfigurationAcquireInfoINTEL(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPerformanceConfigurationTypeINTEL);
}
@@ -8956,14 +11407,20 @@
#ifdef VK_EXT_pci_bus_info
void count_VkPhysicalDevicePCIBusInfoPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint32_t);
@@ -8974,27 +11431,39 @@
#ifdef VK_AMD_display_native_hdr
void count_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkSwapchainDisplayNativeHdrCreateInfoAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -9002,14 +11471,20 @@
#ifdef VK_FUCHSIA_imagepipe_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA);
*count += sizeof(zx_handle_t);
}
@@ -9018,14 +11493,20 @@
#ifdef VK_EXT_metal_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -9036,48 +11517,66 @@
}
#endif
-#ifdef VK_GOOGLE_color_buffer
-void count_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
uint32_t featureBits,
- const VkImportColorBufferGOOGLE* toCount,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- *count += sizeof(uint32_t);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
}
-void count_VkImportBufferGOOGLE(
+void count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
uint32_t featureBits,
- const VkImportBufferGOOGLE* toCount,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- *count += sizeof(uint32_t);
+ 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 += sizeof(VkBool32);
}
-void count_VkImportPhysicalAddressGOOGLE(
+void count_VkRenderPassFragmentDensityMapCreateInfoEXT(
uint32_t featureBits,
- const VkImportPhysicalAddressGOOGLE* toCount,
+ VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- *count += sizeof(uint64_t);
- *count += sizeof(VkDeviceSize);
- *count += sizeof(VkFormat);
- *count += sizeof(VkImageTiling);
- *count += sizeof(uint32_t);
+ 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);
}
#endif
@@ -9090,28 +11589,40 @@
#ifdef VK_EXT_subgroup_size_control
void count_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint32_t);
@@ -9120,14 +11631,20 @@
void count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
@@ -9135,14 +11652,20 @@
#ifdef VK_AMD_shader_core_properties2
void count_VkPhysicalDeviceShaderCoreProperties2AMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkShaderCorePropertiesFlagsAMD);
*count += sizeof(uint32_t);
}
@@ -9151,14 +11674,20 @@
#ifdef VK_AMD_device_coherent_memory
void count_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -9166,14 +11695,20 @@
#ifdef VK_EXT_shader_image_atomic_int64
void count_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
@@ -9182,14 +11717,20 @@
#ifdef VK_EXT_memory_budget
void count_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize);
*count += VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize);
}
@@ -9198,27 +11739,39 @@
#ifdef VK_EXT_memory_priority
void count_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(float);
}
@@ -9226,14 +11779,20 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
void count_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -9241,14 +11800,20 @@
#ifdef VK_EXT_buffer_device_address
void count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -9256,14 +11821,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceAddress);
}
@@ -9271,14 +11842,20 @@
#ifdef VK_EXT_tooling_info
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
*count += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
*count += sizeof(VkToolPurposeFlagsEXT);
@@ -9292,14 +11869,20 @@
#ifdef VK_EXT_validation_features
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
if (toCount)
{
@@ -9316,14 +11899,20 @@
#ifdef VK_NV_cooperative_matrix
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint32_t);
@@ -9336,28 +11925,40 @@
void count_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkShaderStageFlags);
}
@@ -9365,41 +11966,59 @@
#ifdef VK_NV_coverage_reduction_mode
void count_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPipelineCoverageReductionStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCoverageReductionStateCreateFlagsNV);
*count += sizeof(VkCoverageReductionModeNV);
}
void count_VkFramebufferMixedSamplesCombinationNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkCoverageReductionModeNV);
*count += sizeof(VkSampleCountFlagBits);
*count += sizeof(VkSampleCountFlags);
@@ -9410,14 +12029,20 @@
#ifdef VK_EXT_fragment_shader_interlock
void count_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -9427,14 +12052,20 @@
#ifdef VK_EXT_ycbcr_image_arrays
void count_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -9442,40 +12073,58 @@
#ifdef VK_EXT_full_screen_exclusive
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFullScreenExclusiveEXT);
}
void count_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkSurfaceFullScreenExclusiveWin32InfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(HMONITOR);
}
@@ -9483,14 +12132,20 @@
#ifdef VK_EXT_headless_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkHeadlessSurfaceCreateFlagsEXT);
}
@@ -9498,14 +12153,20 @@
#ifdef VK_EXT_line_rasterization
void count_VkPhysicalDeviceLineRasterizationFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -9516,27 +12177,39 @@
void count_VkPhysicalDeviceLineRasterizationPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
void count_VkPipelineRasterizationLineStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkLineRasterizationModeEXT);
*count += sizeof(VkBool32);
*count += sizeof(uint32_t);
@@ -9547,14 +12220,20 @@
#ifdef VK_EXT_shader_atomic_float
void count_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -9575,14 +12254,20 @@
#ifdef VK_EXT_index_type_uint8
void count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -9590,14 +12275,20 @@
#ifdef VK_EXT_extended_dynamic_state
void count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -9605,14 +12296,20 @@
#ifdef VK_EXT_shader_demote_to_helper_invocation
void count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -9620,14 +12317,20 @@
#ifdef VK_NV_device_generated_commands
void count_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint32_t);
@@ -9641,65 +12344,83 @@
void count_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
+ count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
}
}
// WARNING PTR CHECK
*count += 8;
if (toCount->pVertexInputState)
{
- count_VkPipelineVertexInputStateCreateInfo(featureBits, (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
+ count_VkPipelineVertexInputStateCreateInfo(featureBits, rootType, (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
}
// WARNING PTR CHECK
*count += 8;
if (toCount->pTessellationState)
{
- count_VkPipelineTessellationStateCreateInfo(featureBits, (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
+ count_VkPipelineTessellationStateCreateInfo(featureBits, rootType, (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
}
}
void count_VkGraphicsPipelineShaderGroupsCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkGraphicsShaderGroupCreateInfoNV*)(toCount->pGroups + i), count);
+ count_VkGraphicsShaderGroupCreateInfoNV(featureBits, rootType, (const VkGraphicsShaderGroupCreateInfoNV*)(toCount->pGroups + i), count);
}
}
*count += sizeof(uint32_t);
@@ -9711,10 +12432,12 @@
void count_VkBindShaderGroupIndirectCommandNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkBindShaderGroupIndirectCommandNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -9722,10 +12445,12 @@
void count_VkBindIndexBufferIndirectCommandNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkBindIndexBufferIndirectCommandNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceAddress);
@@ -9735,10 +12460,12 @@
void count_VkBindVertexBufferIndirectCommandNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkBindVertexBufferIndirectCommandNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceAddress);
@@ -9748,10 +12475,12 @@
void count_VkSetStateFlagsIndirectCommandNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSetStateFlagsIndirectCommandNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -9759,10 +12488,12 @@
void count_VkIndirectCommandsStreamNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkIndirectCommandsStreamNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
@@ -9772,14 +12503,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkIndirectCommandsTokenTypeNV);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -9804,14 +12541,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -9819,7 +12562,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->tokenCount; ++i)
{
- count_VkIndirectCommandsLayoutTokenNV(featureBits, (const VkIndirectCommandsLayoutTokenNV*)(toCount->pTokens + i), count);
+ count_VkIndirectCommandsLayoutTokenNV(featureBits, rootType, (const VkIndirectCommandsLayoutTokenNV*)(toCount->pTokens + i), count);
}
}
*count += sizeof(uint32_t);
@@ -9831,14 +12574,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -9849,7 +12598,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->streamCount; ++i)
{
- count_VkIndirectCommandsStreamNV(featureBits, (const VkIndirectCommandsStreamNV*)(toCount->pStreams + i), count);
+ count_VkIndirectCommandsStreamNV(featureBits, rootType, (const VkIndirectCommandsStreamNV*)(toCount->pStreams + i), count);
}
}
*count += sizeof(uint32_t);
@@ -9867,14 +12616,20 @@
void count_VkGeneratedCommandsMemoryRequirementsInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -9887,27 +12642,39 @@
#ifdef VK_EXT_texel_buffer_alignment
void count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkBool32);
*count += sizeof(VkDeviceSize);
@@ -9918,56 +12685,80 @@
#ifdef VK_QCOM_render_pass_transform
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSurfaceTransformFlagBitsKHR);
}
void count_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
uint32_t featureBits,
+ VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSurfaceTransformFlagBitsKHR);
- count_VkRect2D(featureBits, (VkRect2D*)(&toCount->renderArea), count);
+ count_VkRect2D(featureBits, rootType, (VkRect2D*)(&toCount->renderArea), count);
}
#endif
#ifdef VK_EXT_device_memory_report
void count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceMemoryReportFlagsEXT);
*count += sizeof(VkDeviceMemoryReportEventTypeEXT);
*count += sizeof(uint64_t);
@@ -9979,14 +12770,20 @@
void count_VkDeviceDeviceMemoryReportCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceMemoryReportFlagsEXT);
*count += 8;
*count += sizeof(uint8_t);
@@ -9996,14 +12793,20 @@
#ifdef VK_EXT_robustness2
void count_VkPhysicalDeviceRobustness2FeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2FeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -10011,14 +12814,20 @@
void count_VkPhysicalDeviceRobustness2PropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
}
@@ -10027,41 +12836,59 @@
#ifdef VK_EXT_custom_border_color
void count_VkSamplerCustomBorderColorCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSamplerCustomBorderColorCreateInfoEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkClearColorValue(featureBits, (VkClearColorValue*)(&toCount->customBorderColor), count);
+ 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 += sizeof(VkFormat);
}
void count_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
void count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
@@ -10072,40 +12899,58 @@
#ifdef VK_EXT_private_data
void count_VkPhysicalDevicePrivateDataFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePrivateDataFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPrivateDataSlotCreateFlagsEXT);
}
@@ -10113,14 +12958,20 @@
#ifdef VK_EXT_pipeline_creation_cache_control
void count_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -10128,27 +12979,39 @@
#ifdef VK_NV_device_diagnostics_config
void count_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkDeviceDiagnosticsConfigCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceDiagnosticsConfigCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceDiagnosticsConfigFlagsNV);
}
@@ -10158,14 +13021,20 @@
#ifdef VK_NV_fragment_shading_rate_enums
void count_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -10173,27 +13042,39 @@
void count_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSampleCountFlagBits);
}
void count_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFragmentShadingRateTypeNV);
*count += sizeof(VkFragmentShadingRateNV);
*count += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
@@ -10203,27 +13084,39 @@
#ifdef VK_EXT_fragment_density_map2
void count_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
void count_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(uint32_t);
@@ -10234,14 +13127,20 @@
#ifdef VK_QCOM_rotated_copy_commands
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSurfaceTransformFlagBitsKHR);
}
@@ -10249,14 +13148,20 @@
#ifdef VK_EXT_image_robustness
void count_VkPhysicalDeviceImageRobustnessFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
@@ -10264,14 +13169,20 @@
#ifdef VK_EXT_4444_formats
void count_VkPhysicalDevice4444FormatsFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
@@ -10280,14 +13191,20 @@
#ifdef VK_EXT_directfb_surface
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -10305,14 +13222,77 @@
#endif
#ifdef VK_GOOGLE_gfxstream
+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)
+ {
+ 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)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ 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)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint64_t);
+ *count += sizeof(VkDeviceSize);
+ *count += sizeof(VkFormat);
+ *count += sizeof(VkImageTiling);
+ *count += sizeof(uint32_t);
+}
+
#endif
#ifdef VK_KHR_acceleration_structure
void count_VkDeviceOrHostAddressKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceOrHostAddressKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceAddress);
@@ -10320,10 +13300,12 @@
void count_VkDeviceOrHostAddressConstKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceOrHostAddressConstKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceAddress);
@@ -10331,10 +13313,12 @@
void count_VkAccelerationStructureBuildRangeInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -10345,87 +13329,119 @@
void count_VkAccelerationStructureGeometryTrianglesDataKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
- count_VkDeviceOrHostAddressConstKHR(featureBits, (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, (VkDeviceOrHostAddressConstKHR*)(&toCount->indexData), count);
- count_VkDeviceOrHostAddressConstKHR(featureBits, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkDeviceOrHostAddressConstKHR(featureBits, (VkDeviceOrHostAddressConstKHR*)(&toCount->data), count);
+ 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 += sizeof(VkDeviceSize);
}
void count_VkAccelerationStructureGeometryInstancesDataKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
- count_VkDeviceOrHostAddressConstKHR(featureBits, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
- count_VkAccelerationStructureGeometryTrianglesDataKHR(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkGeometryTypeKHR);
- count_VkAccelerationStructureGeometryDataKHR(featureBits, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAccelerationStructureTypeKHR);
*count += sizeof(VkBuildAccelerationStructureFlagsKHR);
*count += sizeof(VkBuildAccelerationStructureModeKHR);
@@ -10442,23 +13458,29 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->geometryCount; ++i)
{
- count_VkAccelerationStructureGeometryKHR(featureBits, (const VkAccelerationStructureGeometryKHR*)(toCount->pGeometries + i), count);
+ count_VkAccelerationStructureGeometryKHR(featureBits, rootType, (const VkAccelerationStructureGeometryKHR*)(toCount->pGeometries + i), count);
}
}
}
- count_VkDeviceOrHostAddressKHR(featureBits, (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)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAccelerationStructureCreateFlagsKHR);
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -10470,14 +13492,20 @@
void count_VkWriteDescriptorSetAccelerationStructureKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
@@ -10492,14 +13520,20 @@
void count_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -10509,14 +13543,20 @@
void count_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
*count += sizeof(uint64_t);
*count += sizeof(uint64_t);
@@ -10529,28 +13569,40 @@
void count_VkAccelerationStructureDeviceAddressInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
}
void count_VkAccelerationStructureVersionInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureVersionInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
@@ -10559,31 +13611,43 @@
void count_VkCopyAccelerationStructureToMemoryInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (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)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
- count_VkDeviceOrHostAddressConstKHR(featureBits, (VkDeviceOrHostAddressConstKHR*)(&toCount->src), count);
+ 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);
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(VkCopyAccelerationStructureModeKHR);
@@ -10591,14 +13655,20 @@
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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;
uint64_t cgen_var_1;
@@ -10608,14 +13678,20 @@
void count_VkAccelerationStructureBuildSizesInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
@@ -10625,14 +13701,20 @@
#ifdef VK_KHR_ray_tracing_pipeline
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkRayTracingShaderGroupTypeKHR);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -10648,35 +13730,47 @@
void count_VkRayTracingPipelineInterfaceCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
}
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
+ count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
}
}
*count += sizeof(uint32_t);
@@ -10684,7 +13778,7 @@
{
for (uint32_t i = 0; i < (uint32_t)toCount->groupCount; ++i)
{
- count_VkRayTracingShaderGroupCreateInfoKHR(featureBits, (const VkRayTracingShaderGroupCreateInfoKHR*)(toCount->pGroups + i), count);
+ count_VkRayTracingShaderGroupCreateInfoKHR(featureBits, rootType, (const VkRayTracingShaderGroupCreateInfoKHR*)(toCount->pGroups + i), count);
}
}
*count += sizeof(uint32_t);
@@ -10692,19 +13786,19 @@
*count += 8;
if (toCount->pLibraryInfo)
{
- count_VkPipelineLibraryCreateInfoKHR(featureBits, (const VkPipelineLibraryCreateInfoKHR*)(toCount->pLibraryInfo), count);
+ count_VkPipelineLibraryCreateInfoKHR(featureBits, rootType, (const VkPipelineLibraryCreateInfoKHR*)(toCount->pLibraryInfo), count);
}
// WARNING PTR CHECK
*count += 8;
if (toCount->pLibraryInterface)
{
- count_VkRayTracingPipelineInterfaceCreateInfoKHR(featureBits, (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(toCount->pLibraryInterface), count);
+ count_VkRayTracingPipelineInterfaceCreateInfoKHR(featureBits, rootType, (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(toCount->pLibraryInterface), count);
}
// WARNING PTR CHECK
*count += 8;
if (toCount->pDynamicState)
{
- count_VkPipelineDynamicStateCreateInfo(featureBits, (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
+ count_VkPipelineDynamicStateCreateInfo(featureBits, rootType, (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
}
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -10715,14 +13809,20 @@
void count_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -10732,14 +13832,20 @@
void count_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- count_extension_struct(featureBits, toCount->pNext, count);
+ 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);
*count += sizeof(uint32_t);
@@ -10752,10 +13858,12 @@
void count_VkStridedDeviceAddressRegionKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkStridedDeviceAddressRegionKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkDeviceAddress);
@@ -10765,10 +13873,12 @@
void count_VkTraceRaysIndirectCommandKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkTraceRaysIndirectCommandKHR* toCount,
size_t* count)
{
(void)featureBits;
+ (void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
@@ -10780,29 +13890,36 @@
#ifdef VK_KHR_ray_query
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);
- count_extension_struct(featureBits, toCount->pNext, count);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
#endif
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, 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, (void*)structAccess->pNext, count);
+ count_extension_struct(featureBits, rootType, (void*)structAccess->pNext, count);
return;
}
else
@@ -10826,1535 +13943,1613 @@
#ifdef VK_VERSION_1_1
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
{
- count_VkPhysicalDeviceSubgroupProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), count);
+ count_VkPhysicalDeviceSubgroupProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
{
- count_VkPhysicalDevice16BitStorageFeatures(featureBits, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), count);
+ count_VkPhysicalDevice16BitStorageFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
{
- count_VkMemoryDedicatedRequirements(featureBits, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), count);
+ count_VkMemoryDedicatedRequirements(featureBits, rootType, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
{
- count_VkMemoryDedicatedAllocateInfo(featureBits, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), count);
+ count_VkMemoryDedicatedAllocateInfo(featureBits, rootType, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
{
- count_VkMemoryAllocateFlagsInfo(featureBits, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), count);
+ count_VkMemoryAllocateFlagsInfo(featureBits, rootType, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
{
- count_VkDeviceGroupRenderPassBeginInfo(featureBits, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), count);
+ count_VkDeviceGroupRenderPassBeginInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
{
- count_VkDeviceGroupCommandBufferBeginInfo(featureBits, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), count);
+ count_VkDeviceGroupCommandBufferBeginInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
{
- count_VkDeviceGroupSubmitInfo(featureBits, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), count);
+ count_VkDeviceGroupSubmitInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
{
- count_VkDeviceGroupBindSparseInfo(featureBits, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), count);
+ count_VkDeviceGroupBindSparseInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
{
- count_VkBindBufferMemoryDeviceGroupInfo(featureBits, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), count);
+ count_VkBindBufferMemoryDeviceGroupInfo(featureBits, rootType, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
{
- count_VkBindImageMemoryDeviceGroupInfo(featureBits, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), count);
+ count_VkBindImageMemoryDeviceGroupInfo(featureBits, rootType, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
{
- count_VkDeviceGroupDeviceCreateInfo(featureBits, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), count);
+ count_VkDeviceGroupDeviceCreateInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
{
- count_VkPhysicalDeviceFeatures2(featureBits, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), count);
+ count_VkPhysicalDeviceFeatures2(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
{
- count_VkPhysicalDevicePointClippingProperties(featureBits, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension), count);
+ 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, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), count);
+ count_VkRenderPassInputAttachmentAspectCreateInfo(featureBits, rootType, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
{
- count_VkImageViewUsageCreateInfo(featureBits, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), count);
+ count_VkPipelineTessellationDomainOriginStateCreateInfo(featureBits, rootType, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
{
- count_VkRenderPassMultiviewCreateInfo(featureBits, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), count);
+ count_VkRenderPassMultiviewCreateInfo(featureBits, rootType, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
{
- count_VkPhysicalDeviceMultiviewFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceMultiviewFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
{
- count_VkPhysicalDeviceMultiviewProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), count);
+ count_VkPhysicalDeviceMultiviewProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
{
- count_VkPhysicalDeviceVariablePointersFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceVariablePointersFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
{
- count_VkPhysicalDeviceProtectedMemoryFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceProtectedMemoryFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
{
- count_VkPhysicalDeviceProtectedMemoryProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), count);
+ count_VkPhysicalDeviceProtectedMemoryProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
{
- count_VkProtectedSubmitInfo(featureBits, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), count);
+ count_VkProtectedSubmitInfo(featureBits, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
{
- count_VkSamplerYcbcrConversionInfo(featureBits, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), count);
+ count_VkSamplerYcbcrConversionInfo(featureBits, rootType, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
{
- count_VkBindImagePlaneMemoryInfo(featureBits, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), count);
+ count_VkBindImagePlaneMemoryInfo(featureBits, rootType, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
{
- count_VkImagePlaneMemoryRequirementsInfo(featureBits, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), count);
+ count_VkImagePlaneMemoryRequirementsInfo(featureBits, rootType, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
{
- count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
{
- count_VkSamplerYcbcrConversionImageFormatProperties(featureBits, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), count);
+ count_VkSamplerYcbcrConversionImageFormatProperties(featureBits, rootType, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
{
- count_VkPhysicalDeviceExternalImageFormatInfo(featureBits, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), count);
+ count_VkPhysicalDeviceExternalImageFormatInfo(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
{
- count_VkExternalImageFormatProperties(featureBits, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), count);
+ count_VkExternalImageFormatProperties(featureBits, rootType, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
{
- count_VkPhysicalDeviceIDProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), count);
+ count_VkPhysicalDeviceIDProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
{
- count_VkExternalMemoryImageCreateInfo(featureBits, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), count);
+ count_VkExternalMemoryImageCreateInfo(featureBits, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
{
- count_VkExternalMemoryBufferCreateInfo(featureBits, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), count);
+ count_VkExternalMemoryBufferCreateInfo(featureBits, rootType, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
{
- count_VkExportMemoryAllocateInfo(featureBits, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), count);
+ count_VkExportMemoryAllocateInfo(featureBits, rootType, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
{
- count_VkExportFenceCreateInfo(featureBits, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), count);
+ count_VkExportFenceCreateInfo(featureBits, rootType, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
{
- count_VkExportSemaphoreCreateInfo(featureBits, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), count);
+ count_VkExportSemaphoreCreateInfo(featureBits, rootType, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
{
- count_VkPhysicalDeviceMaintenance3Properties(featureBits, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), count);
+ count_VkPhysicalDeviceMaintenance3Properties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
{
- count_VkPhysicalDeviceShaderDrawParametersFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), count);
+ count_VkPhysicalDeviceVulkan11Features(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
{
- count_VkPhysicalDeviceVulkan11Properties(featureBits, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), count);
+ count_VkPhysicalDeviceVulkan11Properties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
{
- count_VkPhysicalDeviceVulkan12Features(featureBits, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), count);
+ count_VkPhysicalDeviceVulkan12Features(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
{
- count_VkPhysicalDeviceVulkan12Properties(featureBits, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), count);
+ count_VkPhysicalDeviceVulkan12Properties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
{
- count_VkImageFormatListCreateInfo(featureBits, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), count);
+ count_VkImageFormatListCreateInfo(featureBits, rootType, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
{
- count_VkPhysicalDevice8BitStorageFeatures(featureBits, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), count);
+ count_VkPhysicalDevice8BitStorageFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
{
- count_VkPhysicalDeviceDriverProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), count);
+ count_VkPhysicalDeviceDriverProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
{
- count_VkPhysicalDeviceShaderAtomicInt64Features(featureBits, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), count);
+ count_VkPhysicalDeviceShaderAtomicInt64Features(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
{
- count_VkPhysicalDeviceShaderFloat16Int8Features(featureBits, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), count);
+ count_VkPhysicalDeviceShaderFloat16Int8Features(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
{
- count_VkPhysicalDeviceFloatControlsProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension), count);
+ 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, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), count);
+ count_VkDescriptorSetLayoutBindingFlagsCreateInfo(featureBits, rootType, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
{
- count_VkPhysicalDeviceDescriptorIndexingFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceDescriptorIndexingFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
{
- count_VkPhysicalDeviceDescriptorIndexingProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension), count);
+ 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, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension), count);
+ 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, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), count);
+ count_VkDescriptorSetVariableDescriptorCountLayoutSupport(featureBits, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
{
- count_VkSubpassDescriptionDepthStencilResolve(featureBits, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), count);
+ count_VkSubpassDescriptionDepthStencilResolve(featureBits, rootType, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
{
- count_VkPhysicalDeviceDepthStencilResolveProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), count);
+ count_VkPhysicalDeviceDepthStencilResolveProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
{
- count_VkPhysicalDeviceScalarBlockLayoutFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceScalarBlockLayoutFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
{
- count_VkImageStencilUsageCreateInfo(featureBits, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), count);
+ count_VkImageStencilUsageCreateInfo(featureBits, rootType, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
{
- count_VkSamplerReductionModeCreateInfo(featureBits, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), count);
+ count_VkSamplerReductionModeCreateInfo(featureBits, rootType, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
{
- count_VkPhysicalDeviceSamplerFilterMinmaxProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), count);
+ count_VkPhysicalDeviceSamplerFilterMinmaxProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
{
- count_VkPhysicalDeviceVulkanMemoryModelFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceVulkanMemoryModelFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
{
- count_VkPhysicalDeviceImagelessFramebufferFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceImagelessFramebufferFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
{
- count_VkFramebufferAttachmentsCreateInfo(featureBits, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), count);
+ count_VkFramebufferAttachmentsCreateInfo(featureBits, rootType, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
{
- count_VkRenderPassAttachmentBeginInfo(featureBits, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
{
- count_VkAttachmentReferenceStencilLayout(featureBits, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), count);
+ count_VkAttachmentReferenceStencilLayout(featureBits, rootType, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
{
- count_VkAttachmentDescriptionStencilLayout(featureBits, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), count);
+ count_VkAttachmentDescriptionStencilLayout(featureBits, rootType, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
{
- count_VkPhysicalDeviceHostQueryResetFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceHostQueryResetFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
{
- count_VkPhysicalDeviceTimelineSemaphoreFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceTimelineSemaphoreFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
{
- count_VkPhysicalDeviceTimelineSemaphoreProperties(featureBits, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), count);
+ count_VkPhysicalDeviceTimelineSemaphoreProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
{
- count_VkSemaphoreTypeCreateInfo(featureBits, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), count);
+ count_VkSemaphoreTypeCreateInfo(featureBits, rootType, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
{
- count_VkTimelineSemaphoreSubmitInfo(featureBits, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), count);
+ count_VkTimelineSemaphoreSubmitInfo(featureBits, rootType, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
{
- count_VkPhysicalDeviceBufferDeviceAddressFeatures(featureBits, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), count);
+ count_VkPhysicalDeviceBufferDeviceAddressFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
{
- count_VkBufferOpaqueCaptureAddressCreateInfo(featureBits, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), count);
+ count_VkBufferOpaqueCaptureAddressCreateInfo(featureBits, rootType, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
{
- count_VkMemoryOpaqueCaptureAddressAllocateInfo(featureBits, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension), count);
+ 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, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), count);
+ count_VkImageSwapchainCreateInfoKHR(featureBits, rootType, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
{
- count_VkBindImageMemorySwapchainInfoKHR(featureBits, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), count);
+ count_VkBindImageMemorySwapchainInfoKHR(featureBits, rootType, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
{
- count_VkDeviceGroupPresentInfoKHR(featureBits, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), count);
+ count_VkDeviceGroupPresentInfoKHR(featureBits, rootType, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
{
- count_VkDeviceGroupSwapchainCreateInfoKHR(featureBits, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), count);
+ count_VkDisplayPresentInfoKHR(featureBits, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- count_VkImportMemoryWin32HandleInfoKHR(featureBits, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), count);
+ count_VkImportMemoryWin32HandleInfoKHR(featureBits, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- count_VkExportMemoryWin32HandleInfoKHR(featureBits, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), count);
+ count_VkExportSemaphoreWin32HandleInfoKHR(featureBits, rootType, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
{
- count_VkD3D12FenceSubmitInfoKHR(featureBits, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), count);
+ count_VkPhysicalDevicePerformanceQueryFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
{
- count_VkPhysicalDevicePerformanceQueryPropertiesKHR(featureBits, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), count);
+ count_VkPhysicalDevicePerformanceQueryPropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
{
- count_VkQueryPoolPerformanceCreateInfoKHR(featureBits, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), count);
+ count_VkQueryPoolPerformanceCreateInfoKHR(featureBits, rootType, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
{
- count_VkPerformanceQuerySubmitInfoKHR(featureBits, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), count);
+ count_VkPhysicalDevicePortabilitySubsetFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
{
- count_VkPhysicalDevicePortabilitySubsetPropertiesKHR(featureBits, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), count);
+ count_VkSurfaceProtectedCapabilitiesKHR(featureBits, rootType, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
{
- count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(featureBits, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), count);
+ count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
{
- count_VkNativeBufferANDROID(featureBits, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), count);
+ 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, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension), count);
+ 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, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), count);
+ count_VkDedicatedAllocationImageCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
{
- count_VkDedicatedAllocationBufferCreateInfoNV(featureBits, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), count);
+ count_VkDedicatedAllocationBufferCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
{
- count_VkDedicatedAllocationMemoryAllocateInfoNV(featureBits, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
{
- count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(featureBits, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), count);
+ count_VkPipelineRasterizationStateStreamCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
{
- count_VkTextureLODGatherFormatPropertiesAMD(featureBits, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), count);
+ count_VkExternalMemoryImageCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
{
- count_VkExportMemoryAllocateInfoNV(featureBits, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), count);
+ count_VkImportMemoryWin32HandleInfoNV(featureBits, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
{
- count_VkExportMemoryWin32HandleInfoNV(featureBits, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), count);
+ count_VkImageViewASTCDecodeModeEXT(featureBits, rootType, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
{
- count_VkPhysicalDeviceASTCDecodeFeaturesEXT(featureBits, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), count);
+ count_VkAndroidHardwareBufferUsageANDROID(featureBits, rootType, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
{
- count_VkAndroidHardwareBufferFormatPropertiesANDROID(featureBits, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), count);
+ count_VkAndroidHardwareBufferFormatPropertiesANDROID(featureBits, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
{
- count_VkImportAndroidHardwareBufferInfoANDROID(featureBits, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), count);
+ count_VkImportAndroidHardwareBufferInfoANDROID(featureBits, rootType, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
{
- count_VkExternalFormatANDROID(featureBits, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), count);
+ count_VkExternalFormatANDROID(featureBits, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
{
- count_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(featureBits, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), count);
+ count_VkPipelineSampleLocationsStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
{
- count_VkPhysicalDeviceSampleLocationsPropertiesEXT(featureBits, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), count);
+ count_VkImageDrmFormatModifierExplicitCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_validation_cache
case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
{
- count_VkShaderModuleValidationCacheCreateInfoEXT(featureBits, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), count);
+ count_VkWriteDescriptorSetAccelerationStructureNV(featureBits, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
{
- count_VkPhysicalDeviceRayTracingPropertiesNV(featureBits, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), count);
+ count_VkPhysicalDeviceShaderCorePropertiesAMD(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), count);
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
{
- count_VkDeviceMemoryOverallocationCreateInfoAMD(featureBits, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), count);
+ count_VkPhysicalDeviceMeshShaderFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
{
- count_VkPhysicalDeviceMeshShaderPropertiesNV(featureBits, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), count);
+ count_VkPipelineViewportExclusiveScissorStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
{
- count_VkPhysicalDeviceExclusiveScissorFeaturesNV(featureBits, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension), count);
+ 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, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension), count);
+ 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, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), count);
+ count_VkSwapchainDisplayNativeHdrCreateInfoAMD(featureBits, rootType, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), count);
break;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- count_VkImportColorBufferGOOGLE(featureBits, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), count);
+ 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);
+ break;
+ }
+ 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);
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- count_VkImportBufferGOOGLE(featureBits, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), count);
+ 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);
+ break;
+ }
+ default:
+ {
+ count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), count);
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- count_VkImportPhysicalAddressGOOGLE(featureBits, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), count);
+ 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);
+ break;
+ }
+ 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);
+ break;
+ }
+ }
break;
}
#endif
#ifdef VK_EXT_subgroup_size_control
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
{
- count_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(featureBits, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDeviceMemoryPriorityFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
{
- count_VkMemoryPriorityAllocateInfoEXT(featureBits, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
{
- count_VkBufferDeviceAddressCreateInfoEXT(featureBits, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), count);
+ count_VkPhysicalDeviceCooperativeMatrixFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
{
- count_VkPhysicalDeviceCooperativeMatrixPropertiesNV(featureBits, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
{
- count_VkSurfaceFullScreenExclusiveInfoEXT(featureBits, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), count);
+ count_VkSurfaceFullScreenExclusiveInfoEXT(featureBits, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
{
- count_VkSurfaceCapabilitiesFullScreenExclusiveEXT(featureBits, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDeviceLineRasterizationFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
{
- count_VkPhysicalDeviceLineRasterizationPropertiesEXT(featureBits, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(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, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), count);
+ count_VkGraphicsPipelineShaderGroupsCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
{
- count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(featureBits, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension), count);
+ 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, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDeviceRobustness2FeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
{
- count_VkPhysicalDeviceRobustness2PropertiesEXT(featureBits, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDevicePrivateDataFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
{
- count_VkDevicePrivateDataCreateInfoEXT(featureBits, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), count);
+ count_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
{
- count_VkDeviceDiagnosticsConfigCreateInfoNV(featureBits, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension), count);
+ 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, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension), count);
+ count_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(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, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension), count);
+ count_VkPhysicalDevice4444FormatsFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(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);
+ break;
+ }
+ 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);
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
- count_VkWriteDescriptorSetAccelerationStructureKHR(featureBits, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), count);
+ count_VkWriteDescriptorSetAccelerationStructureKHR(featureBits, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
{
- count_VkPhysicalDeviceAccelerationStructureFeaturesKHR(featureBits, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), count);
+ count_VkPhysicalDeviceAccelerationStructureFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), count);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
{
- count_VkPhysicalDeviceAccelerationStructurePropertiesKHR(featureBits, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension), count);
+ 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, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), count);
+ count_VkPhysicalDeviceRayQueryFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), count);
break;
}
#endif
diff --git a/system/vulkan_enc/goldfish_vk_counting_guest.h b/system/vulkan_enc/goldfish_vk_counting_guest.h
index f31e021..6f4d3a7 100644
--- a/system/vulkan_enc/goldfish_vk_counting_guest.h
+++ b/system/vulkan_enc/goldfish_vk_counting_guest.h
@@ -36,546 +36,655 @@
#ifdef VK_VERSION_1_0
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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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);
void count_VkPipelineTessellationStateCreateInfo(
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_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);
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_VkPipelineDepthStencilStateCreateInfo(
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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_VkRenderPassBeginInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkRenderPassBeginInfo* toCount,
size_t* count);
@@ -583,191 +692,229 @@
#ifdef VK_VERSION_1_1
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_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_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_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_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_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_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_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_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_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_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_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_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_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_VkPhysicalDeviceSparseImageFormatInfo2(
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);
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);
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);
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_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);
@@ -775,151 +922,181 @@
void count_VkPhysicalDeviceProtectedMemoryFeatures(
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);
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_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_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_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
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);
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_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);
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_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_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_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_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_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);
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);
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);
@@ -929,256 +1106,307 @@
#ifdef VK_VERSION_1_2
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_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_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_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_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_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_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_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);
void count_VkPhysicalDeviceShaderFloat16Int8Features(
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);
void count_VkDescriptorSetLayoutBindingFlagsCreateInfo(
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);
void count_VkPhysicalDeviceDescriptorIndexingProperties(
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);
void count_VkDescriptorSetVariableDescriptorCountLayoutSupport(
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);
void count_VkPhysicalDeviceDepthStencilResolveProperties(
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);
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_VkPhysicalDeviceSamplerFilterMinmaxProperties(
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);
void count_VkPhysicalDeviceImagelessFramebufferFeatures(
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_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_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
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);
void count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
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_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);
void count_VkPhysicalDeviceTimelineSemaphoreFeatures(
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);
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_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_VkPhysicalDeviceBufferDeviceAddressFeatures(
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_VkBufferOpaqueCaptureAddressCreateInfo(
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);
void count_VkDeviceMemoryOpaqueCaptureAddressInfo(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* toCount,
size_t* count);
@@ -1186,11 +1414,13 @@
#ifdef VK_KHR_surface
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);
@@ -1198,41 +1428,49 @@
#ifdef VK_KHR_swapchain
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_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_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_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);
@@ -1240,36 +1478,43 @@
#ifdef VK_KHR_display
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_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_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_VkDisplaySurfaceCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDisplaySurfaceCreateInfoKHR* toCount,
size_t* count);
@@ -1277,6 +1522,7 @@
#ifdef VK_KHR_display_swapchain
void count_VkDisplayPresentInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDisplayPresentInfoKHR* toCount,
size_t* count);
@@ -1284,6 +1530,7 @@
#ifdef VK_KHR_xlib_surface
void count_VkXlibSurfaceCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkXlibSurfaceCreateInfoKHR* toCount,
size_t* count);
@@ -1291,6 +1538,7 @@
#ifdef VK_KHR_xcb_surface
void count_VkXcbSurfaceCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkXcbSurfaceCreateInfoKHR* toCount,
size_t* count);
@@ -1298,6 +1546,7 @@
#ifdef VK_KHR_wayland_surface
void count_VkWaylandSurfaceCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWaylandSurfaceCreateInfoKHR* toCount,
size_t* count);
@@ -1305,6 +1554,7 @@
#ifdef VK_KHR_android_surface
void count_VkAndroidSurfaceCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAndroidSurfaceCreateInfoKHR* toCount,
size_t* count);
@@ -1312,6 +1562,7 @@
#ifdef VK_KHR_win32_surface
void count_VkWin32SurfaceCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWin32SurfaceCreateInfoKHR* toCount,
size_t* count);
@@ -1397,21 +1648,25 @@
#ifdef VK_KHR_external_memory_win32
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_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);
@@ -1419,16 +1674,19 @@
#ifdef VK_KHR_external_memory_fd
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_VkMemoryGetFdInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkMemoryGetFdInfoKHR* toCount,
size_t* count);
@@ -1436,6 +1694,7 @@
#ifdef VK_KHR_win32_keyed_mutex
void count_VkWin32KeyedMutexAcquireReleaseInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* toCount,
size_t* count);
@@ -1453,21 +1712,25 @@
#ifdef VK_KHR_external_semaphore_win32
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_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);
@@ -1475,11 +1738,13 @@
#ifdef VK_KHR_external_semaphore_fd
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);
@@ -1487,6 +1752,7 @@
#ifdef VK_KHR_push_descriptor
void count_VkPhysicalDevicePushDescriptorPropertiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* toCount,
size_t* count);
@@ -1504,16 +1770,19 @@
#ifdef VK_KHR_incremental_present
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_VkPresentRegionsKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPresentRegionsKHR* toCount,
size_t* count);
@@ -1553,6 +1822,7 @@
#ifdef VK_KHR_shared_presentable_image
void count_VkSharedPresentSurfaceCapabilitiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* toCount,
size_t* count);
@@ -1570,16 +1840,19 @@
#ifdef VK_KHR_external_fence_win32
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_VkFenceGetWin32HandleInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkFenceGetWin32HandleInfoKHR* toCount,
size_t* count);
@@ -1587,11 +1860,13 @@
#ifdef VK_KHR_external_fence_fd
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);
@@ -1599,41 +1874,49 @@
#ifdef VK_KHR_performance_query
void count_VkPhysicalDevicePerformanceQueryFeaturesKHR(
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);
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_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_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);
@@ -1653,16 +1936,19 @@
#ifdef VK_KHR_get_surface_capabilities2
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_VkSurfaceFormat2KHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSurfaceFormat2KHR* toCount,
size_t* count);
@@ -1676,26 +1962,31 @@
#ifdef VK_KHR_get_display_properties2
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_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_VkDisplayPlaneCapabilities2KHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilities2KHR* toCount,
size_t* count);
@@ -1749,11 +2040,13 @@
#ifdef VK_KHR_portability_subset
void count_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
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);
@@ -1781,6 +2074,7 @@
#ifdef VK_KHR_shader_clock
void count_VkPhysicalDeviceShaderClockFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* toCount,
size_t* count);
@@ -1824,6 +2118,7 @@
#ifdef VK_KHR_shader_terminate_invocation
void count_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toCount,
size_t* count);
@@ -1831,26 +2126,31 @@
#ifdef VK_KHR_fragment_shading_rate
void count_VkFragmentShadingRateAttachmentInfoKHR(
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);
void count_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
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);
void count_VkPhysicalDeviceFragmentShadingRateKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* toCount,
size_t* count);
@@ -1860,6 +2160,7 @@
#ifdef VK_KHR_surface_protected_capabilities
void count_VkSurfaceProtectedCapabilitiesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSurfaceProtectedCapabilitiesKHR* toCount,
size_t* count);
@@ -1893,36 +2194,43 @@
#ifdef VK_KHR_pipeline_executable_properties
void count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
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_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_VkPipelineExecutableStatisticValueKHR(
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_VkPipelineExecutableInternalRepresentationKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* toCount,
size_t* count);
@@ -1930,6 +2238,7 @@
#ifdef VK_KHR_pipeline_library
void count_VkPipelineLibraryCreateInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineLibraryCreateInfoKHR* toCount,
size_t* count);
@@ -1939,56 +2248,67 @@
#ifdef VK_KHR_copy_commands2
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_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_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_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_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_VkResolveImageInfo2KHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkResolveImageInfo2KHR* toCount,
size_t* count);
@@ -1996,6 +2316,7 @@
#ifdef VK_ANDROID_native_buffer
void count_VkNativeBufferANDROID(
uint32_t featureBits,
+ VkStructureType rootType,
const VkNativeBufferANDROID* toCount,
size_t* count);
@@ -2003,6 +2324,7 @@
#ifdef VK_EXT_debug_report
void count_VkDebugReportCallbackCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDebugReportCallbackCreateInfoEXT* toCount,
size_t* count);
@@ -2016,6 +2338,7 @@
#ifdef VK_AMD_rasterization_order
void count_VkPipelineRasterizationStateRasterizationOrderAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* toCount,
size_t* count);
@@ -2027,16 +2350,19 @@
#ifdef VK_EXT_debug_marker
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_VkDebugMarkerMarkerInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDebugMarkerMarkerInfoEXT* toCount,
size_t* count);
@@ -2046,16 +2372,19 @@
#ifdef VK_NV_dedicated_allocation
void count_VkDedicatedAllocationImageCreateInfoNV(
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);
void count_VkDedicatedAllocationMemoryAllocateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* toCount,
size_t* count);
@@ -2063,16 +2392,19 @@
#ifdef VK_EXT_transform_feedback
void count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
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);
void count_VkPipelineRasterizationStateStreamCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* toCount,
size_t* count);
@@ -2080,11 +2412,13 @@
#ifdef VK_NVX_image_view_handle
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);
@@ -2100,6 +2434,7 @@
#ifdef VK_AMD_texture_gather_bias_lod
void count_VkTextureLODGatherFormatPropertiesAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* toCount,
size_t* count);
@@ -2107,11 +2442,13 @@
#ifdef VK_AMD_shader_info
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);
@@ -2121,6 +2458,7 @@
#ifdef VK_GGP_stream_descriptor_surface
void count_VkStreamDescriptorSurfaceCreateInfoGGP(
uint32_t featureBits,
+ VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* toCount,
size_t* count);
@@ -2128,6 +2466,7 @@
#ifdef VK_NV_corner_sampled_image
void count_VkPhysicalDeviceCornerSampledImageFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* toCount,
size_t* count);
@@ -2137,6 +2476,7 @@
#ifdef VK_NV_external_memory_capabilities
void count_VkExternalImageFormatPropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkExternalImageFormatPropertiesNV* toCount,
size_t* count);
@@ -2144,11 +2484,13 @@
#ifdef VK_NV_external_memory
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);
@@ -2156,11 +2498,13 @@
#ifdef VK_NV_external_memory_win32
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);
@@ -2168,6 +2512,7 @@
#ifdef VK_NV_win32_keyed_mutex
void count_VkWin32KeyedMutexAcquireReleaseInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* toCount,
size_t* count);
@@ -2175,6 +2520,7 @@
#ifdef VK_EXT_validation_flags
void count_VkValidationFlagsEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkValidationFlagsEXT* toCount,
size_t* count);
@@ -2182,6 +2528,7 @@
#ifdef VK_NN_vi_surface
void count_VkViSurfaceCreateInfoNN(
uint32_t featureBits,
+ VkStructureType rootType,
const VkViSurfaceCreateInfoNN* toCount,
size_t* count);
@@ -2193,6 +2540,7 @@
#ifdef VK_EXT_texture_compression_astc_hdr
void count_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toCount,
size_t* count);
@@ -2200,11 +2548,13 @@
#ifdef VK_EXT_astc_decode_mode
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);
@@ -2212,16 +2562,19 @@
#ifdef VK_EXT_conditional_rendering
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);
void count_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* toCount,
size_t* count);
@@ -2229,11 +2582,13 @@
#ifdef VK_NV_clip_space_w_scaling
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);
@@ -2245,6 +2600,7 @@
#ifdef VK_EXT_display_surface_counter
void count_VkSurfaceCapabilities2EXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSurfaceCapabilities2EXT* toCount,
size_t* count);
@@ -2252,21 +2608,25 @@
#ifdef VK_EXT_display_control
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_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);
@@ -2274,21 +2634,25 @@
#ifdef VK_GOOGLE_display_timing
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_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);
@@ -2302,6 +2666,7 @@
#ifdef VK_NVX_multiview_per_view_attributes
void count_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toCount,
size_t* count);
@@ -2309,11 +2674,13 @@
#ifdef VK_NV_viewport_swizzle
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);
@@ -2321,11 +2688,13 @@
#ifdef VK_EXT_discard_rectangles
void count_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
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);
@@ -2333,11 +2702,13 @@
#ifdef VK_EXT_conservative_rasterization
void count_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
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);
@@ -2345,11 +2716,13 @@
#ifdef VK_EXT_depth_clip_enable
void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
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);
@@ -2359,11 +2732,13 @@
#ifdef VK_EXT_hdr_metadata
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);
@@ -2371,6 +2746,7 @@
#ifdef VK_MVK_ios_surface
void count_VkIOSSurfaceCreateInfoMVK(
uint32_t featureBits,
+ VkStructureType rootType,
const VkIOSSurfaceCreateInfoMVK* toCount,
size_t* count);
@@ -2378,6 +2754,7 @@
#ifdef VK_MVK_macos_surface
void count_VkMacOSSurfaceCreateInfoMVK(
uint32_t featureBits,
+ VkStructureType rootType,
const VkMacOSSurfaceCreateInfoMVK* toCount,
size_t* count);
@@ -2391,26 +2768,31 @@
#ifdef VK_EXT_debug_utils
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_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_VkDebugUtilsObjectTagInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDebugUtilsObjectTagInfoEXT* toCount,
size_t* count);
@@ -2418,31 +2800,37 @@
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
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);
void count_VkAndroidHardwareBufferFormatPropertiesANDROID(
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);
void count_VkMemoryGetAndroidHardwareBufferInfoANDROID(
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);
@@ -2462,21 +2850,25 @@
#ifdef VK_EXT_inline_uniform_block
void count_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
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);
void count_VkWriteDescriptorSetInlineUniformBlockEXT(
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);
@@ -2486,41 +2878,49 @@
#ifdef VK_EXT_sample_locations
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_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_VkRenderPassSampleLocationsBeginInfoEXT(
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);
void count_VkPhysicalDeviceSampleLocationsPropertiesEXT(
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);
@@ -2528,16 +2928,19 @@
#ifdef VK_EXT_blend_operation_advanced
void count_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
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);
void count_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* toCount,
size_t* count);
@@ -2545,6 +2948,7 @@
#ifdef VK_NV_fragment_coverage_to_color
void count_VkPipelineCoverageToColorStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* toCount,
size_t* count);
@@ -2552,6 +2956,7 @@
#ifdef VK_NV_framebuffer_mixed_samples
void count_VkPipelineCoverageModulationStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* toCount,
size_t* count);
@@ -2561,11 +2966,13 @@
#ifdef VK_NV_shader_sm_builtins
void count_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
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);
@@ -2575,31 +2982,37 @@
#ifdef VK_EXT_image_drm_format_modifier
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_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
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);
void count_VkImageDrmFormatModifierExplicitCreateInfoEXT(
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);
@@ -2607,11 +3020,13 @@
#ifdef VK_EXT_validation_cache
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);
@@ -2633,36 +3048,43 @@
#ifdef VK_NV_shading_rate_image
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);
void count_VkPhysicalDeviceShadingRateImageFeaturesNV(
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);
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_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toCount,
size_t* count);
@@ -2670,66 +3092,79 @@
#ifdef VK_NV_ray_tracing
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_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_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_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_VkBindAccelerationStructureMemoryInfoNV(
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);
void count_VkAccelerationStructureMemoryRequirementsInfoNV(
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);
void count_VkTransformMatrixKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkTransformMatrixKHR* toCount,
size_t* count);
@@ -2737,6 +3172,7 @@
void count_VkAabbPositionsKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAabbPositionsKHR* toCount,
size_t* count);
@@ -2744,6 +3180,7 @@
void count_VkAccelerationStructureInstanceKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureInstanceKHR* toCount,
size_t* count);
@@ -2753,11 +3190,13 @@
#ifdef VK_NV_representative_fragment_test
void count_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
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);
@@ -2765,11 +3204,13 @@
#ifdef VK_EXT_filter_cubic
void count_VkPhysicalDeviceImageViewImageFormatInfoEXT(
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);
@@ -2779,6 +3220,7 @@
#ifdef VK_EXT_global_priority
void count_VkDeviceQueueGlobalPriorityCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* toCount,
size_t* count);
@@ -2786,16 +3228,19 @@
#ifdef VK_EXT_external_memory_host
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_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toCount,
size_t* count);
@@ -2805,6 +3250,7 @@
#ifdef VK_AMD_pipeline_compiler_control
void count_VkPipelineCompilerControlCreateInfoAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* toCount,
size_t* count);
@@ -2812,6 +3258,7 @@
#ifdef VK_EXT_calibrated_timestamps
void count_VkCalibratedTimestampInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkCalibratedTimestampInfoEXT* toCount,
size_t* count);
@@ -2819,6 +3266,7 @@
#ifdef VK_AMD_shader_core_properties
void count_VkPhysicalDeviceShaderCorePropertiesAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* toCount,
size_t* count);
@@ -2826,6 +3274,7 @@
#ifdef VK_AMD_memory_overallocation_behavior
void count_VkDeviceMemoryOverallocationCreateInfoAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* toCount,
size_t* count);
@@ -2833,21 +3282,25 @@
#ifdef VK_EXT_vertex_attribute_divisor
void count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
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);
void count_VkPipelineVertexInputDivisorStateCreateInfoEXT(
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);
@@ -2855,6 +3308,7 @@
#ifdef VK_GGP_frame_token
void count_VkPresentFrameTokenGGP(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPresentFrameTokenGGP* toCount,
size_t* count);
@@ -2862,11 +3316,13 @@
#ifdef VK_EXT_pipeline_creation_feedback
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);
@@ -2876,6 +3332,7 @@
#ifdef VK_NV_compute_shader_derivatives
void count_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toCount,
size_t* count);
@@ -2883,16 +3340,19 @@
#ifdef VK_NV_mesh_shader
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);
void count_VkDrawMeshTasksIndirectCommandNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDrawMeshTasksIndirectCommandNV* toCount,
size_t* count);
@@ -2900,6 +3360,7 @@
#ifdef VK_NV_fragment_shader_barycentric
void count_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toCount,
size_t* count);
@@ -2907,6 +3368,7 @@
#ifdef VK_NV_shader_image_footprint
void count_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* toCount,
size_t* count);
@@ -2914,11 +3376,13 @@
#ifdef VK_NV_scissor_exclusive
void count_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
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);
@@ -2926,11 +3390,13 @@
#ifdef VK_NV_device_diagnostic_checkpoints
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);
@@ -2938,6 +3404,7 @@
#ifdef VK_INTEL_shader_integer_functions2
void count_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toCount,
size_t* count);
@@ -2945,21 +3412,25 @@
#ifdef VK_INTEL_performance_query
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_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);
@@ -2967,21 +3438,25 @@
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_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);
@@ -2989,6 +3464,7 @@
#ifdef VK_EXT_pci_bus_info
void count_VkPhysicalDevicePCIBusInfoPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* toCount,
size_t* count);
@@ -2996,11 +3472,13 @@
#ifdef VK_AMD_display_native_hdr
void count_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
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);
@@ -3008,6 +3486,7 @@
#ifdef VK_FUCHSIA_imagepipe_surface
void count_VkImagePipeSurfaceCreateInfoFUCHSIA(
uint32_t featureBits,
+ VkStructureType rootType,
const VkImagePipeSurfaceCreateInfoFUCHSIA* toCount,
size_t* count);
@@ -3015,24 +3494,28 @@
#ifdef VK_EXT_metal_surface
void count_VkMetalSurfaceCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkMetalSurfaceCreateInfoEXT* toCount,
size_t* count);
#endif
-#ifdef VK_GOOGLE_color_buffer
-void count_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
uint32_t featureBits,
- const VkImportColorBufferGOOGLE* toCount,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toCount,
size_t* count);
-void count_VkImportBufferGOOGLE(
+void count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
uint32_t featureBits,
- const VkImportBufferGOOGLE* toCount,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toCount,
size_t* count);
-void count_VkImportPhysicalAddressGOOGLE(
+void count_VkRenderPassFragmentDensityMapCreateInfoEXT(
uint32_t featureBits,
- const VkImportPhysicalAddressGOOGLE* toCount,
+ VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* toCount,
size_t* count);
#endif
@@ -3047,16 +3530,19 @@
#ifdef VK_EXT_subgroup_size_control
void count_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
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);
void count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toCount,
size_t* count);
@@ -3064,6 +3550,7 @@
#ifdef VK_AMD_shader_core_properties2
void count_VkPhysicalDeviceShaderCoreProperties2AMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* toCount,
size_t* count);
@@ -3071,6 +3558,7 @@
#ifdef VK_AMD_device_coherent_memory
void count_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* toCount,
size_t* count);
@@ -3078,6 +3566,7 @@
#ifdef VK_EXT_shader_image_atomic_int64
void count_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toCount,
size_t* count);
@@ -3085,6 +3574,7 @@
#ifdef VK_EXT_memory_budget
void count_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* toCount,
size_t* count);
@@ -3092,11 +3582,13 @@
#ifdef VK_EXT_memory_priority
void count_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
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);
@@ -3104,6 +3596,7 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
void count_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toCount,
size_t* count);
@@ -3111,6 +3604,7 @@
#ifdef VK_EXT_buffer_device_address
void count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toCount,
size_t* count);
@@ -3120,6 +3614,7 @@
void count_VkBufferDeviceAddressCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkBufferDeviceAddressCreateInfoEXT* toCount,
size_t* count);
@@ -3127,6 +3622,7 @@
#ifdef VK_EXT_tooling_info
void count_VkPhysicalDeviceToolPropertiesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceToolPropertiesEXT* toCount,
size_t* count);
@@ -3138,6 +3634,7 @@
#ifdef VK_EXT_validation_features
void count_VkValidationFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkValidationFeaturesEXT* toCount,
size_t* count);
@@ -3145,16 +3642,19 @@
#ifdef VK_NV_cooperative_matrix
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);
void count_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* toCount,
size_t* count);
@@ -3162,16 +3662,19 @@
#ifdef VK_NV_coverage_reduction_mode
void count_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
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);
void count_VkFramebufferMixedSamplesCombinationNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* toCount,
size_t* count);
@@ -3179,6 +3682,7 @@
#ifdef VK_EXT_fragment_shader_interlock
void count_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toCount,
size_t* count);
@@ -3186,6 +3690,7 @@
#ifdef VK_EXT_ycbcr_image_arrays
void count_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toCount,
size_t* count);
@@ -3193,16 +3698,19 @@
#ifdef VK_EXT_full_screen_exclusive
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);
void count_VkSurfaceFullScreenExclusiveWin32InfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* toCount,
size_t* count);
@@ -3210,6 +3718,7 @@
#ifdef VK_EXT_headless_surface
void count_VkHeadlessSurfaceCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkHeadlessSurfaceCreateInfoEXT* toCount,
size_t* count);
@@ -3217,16 +3726,19 @@
#ifdef VK_EXT_line_rasterization
void count_VkPhysicalDeviceLineRasterizationFeaturesEXT(
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);
void count_VkPipelineRasterizationLineStateCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* toCount,
size_t* count);
@@ -3234,6 +3746,7 @@
#ifdef VK_EXT_shader_atomic_float
void count_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toCount,
size_t* count);
@@ -3245,6 +3758,7 @@
#ifdef VK_EXT_index_type_uint8
void count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toCount,
size_t* count);
@@ -3252,6 +3766,7 @@
#ifdef VK_EXT_extended_dynamic_state
void count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toCount,
size_t* count);
@@ -3259,6 +3774,7 @@
#ifdef VK_EXT_shader_demote_to_helper_invocation
void count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toCount,
size_t* count);
@@ -3266,66 +3782,79 @@
#ifdef VK_NV_device_generated_commands
void count_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
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);
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);
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_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_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_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_VkGeneratedCommandsMemoryRequirementsInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* toCount,
size_t* count);
@@ -3333,11 +3862,13 @@
#ifdef VK_EXT_texel_buffer_alignment
void count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
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);
@@ -3345,11 +3876,13 @@
#ifdef VK_QCOM_render_pass_transform
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);
@@ -3357,16 +3890,19 @@
#ifdef VK_EXT_device_memory_report
void count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
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_VkDeviceDeviceMemoryReportCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* toCount,
size_t* count);
@@ -3374,11 +3910,13 @@
#ifdef VK_EXT_robustness2
void count_VkPhysicalDeviceRobustness2FeaturesEXT(
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);
@@ -3386,16 +3924,19 @@
#ifdef VK_EXT_custom_border_color
void count_VkSamplerCustomBorderColorCreateInfoEXT(
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);
void count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* toCount,
size_t* count);
@@ -3405,16 +3946,19 @@
#ifdef VK_EXT_private_data
void count_VkPhysicalDevicePrivateDataFeaturesEXT(
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_VkPrivateDataSlotCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPrivateDataSlotCreateInfoEXT* toCount,
size_t* count);
@@ -3422,6 +3966,7 @@
#ifdef VK_EXT_pipeline_creation_cache_control
void count_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toCount,
size_t* count);
@@ -3429,11 +3974,13 @@
#ifdef VK_NV_device_diagnostics_config
void count_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
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);
@@ -3443,16 +3990,19 @@
#ifdef VK_NV_fragment_shading_rate_enums
void count_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
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);
void count_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toCount,
size_t* count);
@@ -3460,11 +4010,13 @@
#ifdef VK_EXT_fragment_density_map2
void count_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
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);
@@ -3472,6 +4024,7 @@
#ifdef VK_QCOM_rotated_copy_commands
void count_VkCopyCommandTransformInfoQCOM(
uint32_t featureBits,
+ VkStructureType rootType,
const VkCopyCommandTransformInfoQCOM* toCount,
size_t* count);
@@ -3479,6 +4032,7 @@
#ifdef VK_EXT_image_robustness
void count_VkPhysicalDeviceImageRobustnessFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* toCount,
size_t* count);
@@ -3486,6 +4040,7 @@
#ifdef VK_EXT_4444_formats
void count_VkPhysicalDevice4444FormatsFeaturesEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* toCount,
size_t* count);
@@ -3493,105 +4048,143 @@
#ifdef VK_EXT_directfb_surface
void count_VkDirectFBSurfaceCreateInfoEXT(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDirectFBSurfaceCreateInfoEXT* 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_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);
+
#endif
#ifdef VK_KHR_acceleration_structure
void count_VkDeviceOrHostAddressKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceOrHostAddressKHR* toCount,
size_t* count);
void count_VkDeviceOrHostAddressConstKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkDeviceOrHostAddressConstKHR* toCount,
size_t* count);
void count_VkAccelerationStructureBuildRangeInfoKHR(
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);
void count_VkAccelerationStructureGeometryAabbsDataKHR(
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);
void count_VkAccelerationStructureGeometryDataKHR(
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_VkAccelerationStructureBuildGeometryInfoKHR(
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_VkWriteDescriptorSetAccelerationStructureKHR(
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);
void count_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
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);
void count_VkAccelerationStructureVersionInfoKHR(
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);
void count_VkCopyMemoryToAccelerationStructureInfoKHR(
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_VkAccelerationStructureBuildSizesInfoKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* toCount,
size_t* count);
@@ -3599,36 +4192,43 @@
#ifdef VK_KHR_ray_tracing_pipeline
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);
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);
void count_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
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_VkTraceRaysIndirectCommandKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkTraceRaysIndirectCommandKHR* toCount,
size_t* count);
@@ -3636,6 +4236,7 @@
#ifdef VK_KHR_ray_query
void count_VkPhysicalDeviceRayQueryFeaturesKHR(
uint32_t featureBits,
+ VkStructureType rootType,
const VkPhysicalDeviceRayQueryFeaturesKHR* toCount,
size_t* count);
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index ba8cc08..a1be4fb 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -34,341 +34,416 @@
namespace goldfish_vk {
void deepcopy_extension_struct(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const void* structExtension,
void* structExtension_out);
#ifdef VK_VERSION_1_0
void deepcopy_VkExtent2D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExtent2D* from,
VkExtent2D* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkExtent3D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExtent3D* from,
VkExtent3D* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkOffset2D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkOffset2D* from,
VkOffset2D* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkOffset3D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkOffset3D* from,
VkOffset3D* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkRect2D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRect2D* from,
VkRect2D* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkOffset2D(pool, &from->offset, (VkOffset2D*)(&to->offset));
- deepcopy_VkExtent2D(pool, &from->extent, (VkExtent2D*)(&to->extent));
+ deepcopy_VkOffset2D(alloc, rootType, &from->offset, (VkOffset2D*)(&to->offset));
+ deepcopy_VkExtent2D(alloc, rootType, &from->extent, (VkExtent2D*)(&to->extent));
}
void deepcopy_VkBaseInStructure(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBaseInStructure* from,
VkBaseInStructure* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const VkBaseInStructure*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const VkBaseInStructure*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBaseOutStructure(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBaseOutStructure* from,
VkBaseOutStructure* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (VkBaseOutStructure*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (VkBaseOutStructure*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBufferMemoryBarrier(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferMemoryBarrier* from,
VkBufferMemoryBarrier* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDispatchIndirectCommand(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDispatchIndirectCommand* from,
VkDispatchIndirectCommand* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkDrawIndexedIndirectCommand(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrawIndexedIndirectCommand* from,
VkDrawIndexedIndirectCommand* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkDrawIndirectCommand(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrawIndirectCommand* from,
VkDrawIndirectCommand* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkImageSubresourceRange(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSubresourceRange* from,
VkImageSubresourceRange* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkImageMemoryBarrier(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageMemoryBarrier* from,
VkImageMemoryBarrier* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceRange(pool, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
+ deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
}
void deepcopy_VkMemoryBarrier(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryBarrier* from,
VkMemoryBarrier* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAllocationCallbacks(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAllocationCallbacks* from,
VkAllocationCallbacks* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
to->pUserData = nullptr;
if (from->pUserData)
{
- to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+ to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
void deepcopy_VkApplicationInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkApplicationInfo* from,
VkApplicationInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pApplicationName = nullptr;
if (from->pApplicationName)
{
- to->pApplicationName = pool->strDup(from->pApplicationName);
+ to->pApplicationName = alloc->strDup(from->pApplicationName);
}
to->pEngineName = nullptr;
if (from->pEngineName)
{
- to->pEngineName = pool->strDup(from->pEngineName);
+ to->pEngineName = alloc->strDup(from->pEngineName);
}
}
void deepcopy_VkFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFormatProperties* from,
VkFormatProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkImageFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageFormatProperties* from,
VkImageFormatProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkExtent3D(pool, &from->maxExtent, (VkExtent3D*)(&to->maxExtent));
+ deepcopy_VkExtent3D(alloc, rootType, &from->maxExtent, (VkExtent3D*)(&to->maxExtent));
}
void deepcopy_VkInstanceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkInstanceCreateInfo* from,
VkInstanceCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pApplicationInfo = nullptr;
if (from->pApplicationInfo)
{
- to->pApplicationInfo = (VkApplicationInfo*)pool->alloc(sizeof(const VkApplicationInfo));
- deepcopy_VkApplicationInfo(pool, from->pApplicationInfo, (VkApplicationInfo*)(to->pApplicationInfo));
+ to->pApplicationInfo = (VkApplicationInfo*)alloc->alloc(sizeof(const VkApplicationInfo));
+ deepcopy_VkApplicationInfo(alloc, rootType, from->pApplicationInfo, (VkApplicationInfo*)(to->pApplicationInfo));
}
to->ppEnabledLayerNames = nullptr;
if (from->ppEnabledLayerNames && from->enabledLayerCount)
{
- to->ppEnabledLayerNames = pool->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
+ to->ppEnabledLayerNames = alloc->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
}
to->ppEnabledExtensionNames = nullptr;
if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
{
- to->ppEnabledExtensionNames = pool->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
+ to->ppEnabledExtensionNames = alloc->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
}
}
void deepcopy_VkMemoryHeap(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryHeap* from,
VkMemoryHeap* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkMemoryType(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryType* from,
VkMemoryType* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPhysicalDeviceFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures* from,
VkPhysicalDeviceFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPhysicalDeviceLimits(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceLimits* from,
VkPhysicalDeviceLimits* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
memcpy(to->maxComputeWorkGroupCount, from->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
memcpy(to->maxComputeWorkGroupSize, from->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
@@ -379,379 +454,441 @@
}
void deepcopy_VkPhysicalDeviceMemoryProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties* from,
VkPhysicalDeviceMemoryProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
{
- deepcopy_VkMemoryType(pool, from->memoryTypes + i, (VkMemoryType*)(to->memoryTypes + 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(pool, from->memoryHeaps + i, (VkMemoryHeap*)(to->memoryHeaps + i));
+ deepcopy_VkMemoryHeap(alloc, rootType, from->memoryHeaps + i, (VkMemoryHeap*)(to->memoryHeaps + i));
}
}
void deepcopy_VkPhysicalDeviceSparseProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseProperties* from,
VkPhysicalDeviceSparseProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPhysicalDeviceProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceProperties* from,
VkPhysicalDeviceProperties* to)
{
- (void)pool;
+ (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(pool, &from->limits, (VkPhysicalDeviceLimits*)(&to->limits));
- deepcopy_VkPhysicalDeviceSparseProperties(pool, &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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueueFamilyProperties* from,
VkQueueFamilyProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkExtent3D(pool, &from->minImageTransferGranularity, (VkExtent3D*)(&to->minImageTransferGranularity));
+ deepcopy_VkExtent3D(alloc, rootType, &from->minImageTransferGranularity, (VkExtent3D*)(&to->minImageTransferGranularity));
}
void deepcopy_VkDeviceQueueCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceQueueCreateInfo* from,
VkDeviceQueueCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pQueuePriorities = nullptr;
if (from->pQueuePriorities)
{
- to->pQueuePriorities = (float*)pool->dupArray(from->pQueuePriorities, from->queueCount * sizeof(const float));
+ to->pQueuePriorities = (float*)alloc->dupArray(from->pQueuePriorities, from->queueCount * sizeof(const float));
}
}
void deepcopy_VkDeviceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceCreateInfo* from,
VkDeviceCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pQueueCreateInfos = nullptr;
if (from->pQueueCreateInfos)
{
- to->pQueueCreateInfos = (VkDeviceQueueCreateInfo*)pool->alloc(from->queueCreateInfoCount * sizeof(const VkDeviceQueueCreateInfo));
+ 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(pool, from->pQueueCreateInfos + i, (VkDeviceQueueCreateInfo*)(to->pQueueCreateInfos + i));
+ deepcopy_VkDeviceQueueCreateInfo(alloc, rootType, from->pQueueCreateInfos + i, (VkDeviceQueueCreateInfo*)(to->pQueueCreateInfos + i));
}
}
}
to->ppEnabledLayerNames = nullptr;
if (from->ppEnabledLayerNames && from->enabledLayerCount)
{
- to->ppEnabledLayerNames = pool->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
+ to->ppEnabledLayerNames = alloc->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
}
to->ppEnabledExtensionNames = nullptr;
if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
{
- to->ppEnabledExtensionNames = pool->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
+ to->ppEnabledExtensionNames = alloc->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
}
to->pEnabledFeatures = nullptr;
if (from->pEnabledFeatures)
{
- to->pEnabledFeatures = (VkPhysicalDeviceFeatures*)pool->alloc(sizeof(const VkPhysicalDeviceFeatures));
- deepcopy_VkPhysicalDeviceFeatures(pool, from->pEnabledFeatures, (VkPhysicalDeviceFeatures*)(to->pEnabledFeatures));
+ to->pEnabledFeatures = (VkPhysicalDeviceFeatures*)alloc->alloc(sizeof(const VkPhysicalDeviceFeatures));
+ deepcopy_VkPhysicalDeviceFeatures(alloc, rootType, from->pEnabledFeatures, (VkPhysicalDeviceFeatures*)(to->pEnabledFeatures));
}
}
void deepcopy_VkExtensionProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExtensionProperties* from,
VkExtensionProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
memcpy(to->extensionName, from->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
}
void deepcopy_VkLayerProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkLayerProperties* from,
VkLayerProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
memcpy(to->layerName, from->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}
void deepcopy_VkSubmitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubmitInfo* from,
VkSubmitInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphores = nullptr;
if (from->pWaitSemaphores)
{
- to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+ to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
}
to->pWaitDstStageMask = nullptr;
if (from->pWaitDstStageMask)
{
- to->pWaitDstStageMask = (VkPipelineStageFlags*)pool->dupArray(from->pWaitDstStageMask, from->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+ to->pWaitDstStageMask = (VkPipelineStageFlags*)alloc->dupArray(from->pWaitDstStageMask, from->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
}
to->pCommandBuffers = nullptr;
if (from->pCommandBuffers)
{
- to->pCommandBuffers = (VkCommandBuffer*)pool->dupArray(from->pCommandBuffers, from->commandBufferCount * sizeof(const VkCommandBuffer));
+ to->pCommandBuffers = (VkCommandBuffer*)alloc->dupArray(from->pCommandBuffers, from->commandBufferCount * sizeof(const VkCommandBuffer));
}
to->pSignalSemaphores = nullptr;
if (from->pSignalSemaphores)
{
- to->pSignalSemaphores = (VkSemaphore*)pool->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
+ to->pSignalSemaphores = (VkSemaphore*)alloc->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
}
}
void deepcopy_VkMappedMemoryRange(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMappedMemoryRange* from,
VkMappedMemoryRange* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryAllocateInfo* from,
VkMemoryAllocateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryRequirements(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryRequirements* from,
VkMemoryRequirements* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkSparseMemoryBind(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseMemoryBind* from,
VkSparseMemoryBind* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkSparseBufferMemoryBindInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseBufferMemoryBindInfo* from,
VkSparseBufferMemoryBindInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
if (from)
{
to->pBinds = nullptr;
if (from->pBinds)
{
- to->pBinds = (VkSparseMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseMemoryBind));
+ 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(pool, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
+ deepcopy_VkSparseMemoryBind(alloc, rootType, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
}
}
}
}
void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageOpaqueMemoryBindInfo* from,
VkSparseImageOpaqueMemoryBindInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
if (from)
{
to->pBinds = nullptr;
if (from->pBinds)
{
- to->pBinds = (VkSparseMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseMemoryBind));
+ 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(pool, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
+ deepcopy_VkSparseMemoryBind(alloc, rootType, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
}
}
}
}
void deepcopy_VkImageSubresource(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSubresource* from,
VkImageSubresource* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkSparseImageMemoryBind(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageMemoryBind* from,
VkSparseImageMemoryBind* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkImageSubresource(pool, &from->subresource, (VkImageSubresource*)(&to->subresource));
- deepcopy_VkOffset3D(pool, &from->offset, (VkOffset3D*)(&to->offset));
- deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+ 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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageMemoryBindInfo* from,
VkSparseImageMemoryBindInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
if (from)
{
to->pBinds = nullptr;
if (from->pBinds)
{
- to->pBinds = (VkSparseImageMemoryBind*)pool->alloc(from->bindCount * sizeof(const VkSparseImageMemoryBind));
+ 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(pool, from->pBinds + i, (VkSparseImageMemoryBind*)(to->pBinds + i));
+ deepcopy_VkSparseImageMemoryBind(alloc, rootType, from->pBinds + i, (VkSparseImageMemoryBind*)(to->pBinds + i));
}
}
}
}
void deepcopy_VkBindSparseInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindSparseInfo* from,
VkBindSparseInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphores = nullptr;
if (from->pWaitSemaphores)
{
- to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+ to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
}
if (from)
{
to->pBufferBinds = nullptr;
if (from->pBufferBinds)
{
- to->pBufferBinds = (VkSparseBufferMemoryBindInfo*)pool->alloc(from->bufferBindCount * sizeof(const VkSparseBufferMemoryBindInfo));
+ 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(pool, from->pBufferBinds + i, (VkSparseBufferMemoryBindInfo*)(to->pBufferBinds + i));
+ deepcopy_VkSparseBufferMemoryBindInfo(alloc, rootType, from->pBufferBinds + i, (VkSparseBufferMemoryBindInfo*)(to->pBufferBinds + i));
}
}
}
@@ -760,11 +897,11 @@
to->pImageOpaqueBinds = nullptr;
if (from->pImageOpaqueBinds)
{
- to->pImageOpaqueBinds = (VkSparseImageOpaqueMemoryBindInfo*)pool->alloc(from->imageOpaqueBindCount * sizeof(const VkSparseImageOpaqueMemoryBindInfo));
+ 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(pool, from->pImageOpaqueBinds + i, (VkSparseImageOpaqueMemoryBindInfo*)(to->pImageOpaqueBinds + i));
+ deepcopy_VkSparseImageOpaqueMemoryBindInfo(alloc, rootType, from->pImageOpaqueBinds + i, (VkSparseImageOpaqueMemoryBindInfo*)(to->pImageOpaqueBinds + i));
}
}
}
@@ -773,442 +910,536 @@
to->pImageBinds = nullptr;
if (from->pImageBinds)
{
- to->pImageBinds = (VkSparseImageMemoryBindInfo*)pool->alloc(from->imageBindCount * sizeof(const VkSparseImageMemoryBindInfo));
+ 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(pool, from->pImageBinds + i, (VkSparseImageMemoryBindInfo*)(to->pImageBinds + i));
+ deepcopy_VkSparseImageMemoryBindInfo(alloc, rootType, from->pImageBinds + i, (VkSparseImageMemoryBindInfo*)(to->pImageBinds + i));
}
}
}
to->pSignalSemaphores = nullptr;
if (from->pSignalSemaphores)
{
- to->pSignalSemaphores = (VkSemaphore*)pool->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
+ to->pSignalSemaphores = (VkSemaphore*)alloc->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
}
}
void deepcopy_VkSparseImageFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageFormatProperties* from,
VkSparseImageFormatProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkExtent3D(pool, &from->imageGranularity, (VkExtent3D*)(&to->imageGranularity));
+ deepcopy_VkExtent3D(alloc, rootType, &from->imageGranularity, (VkExtent3D*)(&to->imageGranularity));
}
void deepcopy_VkSparseImageMemoryRequirements(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements* from,
VkSparseImageMemoryRequirements* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkSparseImageFormatProperties(pool, &from->formatProperties, (VkSparseImageFormatProperties*)(&to->formatProperties));
+ deepcopy_VkSparseImageFormatProperties(alloc, rootType, &from->formatProperties, (VkSparseImageFormatProperties*)(&to->formatProperties));
}
void deepcopy_VkFenceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFenceCreateInfo* from,
VkFenceCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSemaphoreCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreCreateInfo* from,
VkSemaphoreCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkEventCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkEventCreateInfo* from,
VkEventCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkQueryPoolCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueryPoolCreateInfo* from,
VkQueryPoolCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBufferCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferCreateInfo* from,
VkBufferCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+ to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkBufferViewCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferViewCreateInfo* from,
VkBufferViewCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkImageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageCreateInfo* from,
VkImageCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+ deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
to->pQueueFamilyIndices = nullptr;
if (from->pQueueFamilyIndices)
{
- to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+ to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkSubresourceLayout(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubresourceLayout* from,
VkSubresourceLayout* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkComponentMapping(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkComponentMapping* from,
VkComponentMapping* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkImageViewCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewCreateInfo* from,
VkImageViewCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkComponentMapping(pool, &from->components, (VkComponentMapping*)(&to->components));
- deepcopy_VkImageSubresourceRange(pool, &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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShaderModuleCreateInfo* from,
VkShaderModuleCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pCode, (from->codeSize / 4) * sizeof(const uint32_t));
+ to->pCode = (uint32_t*)alloc->dupArray(from->pCode, (from->codeSize / 4) * sizeof(const uint32_t));
}
}
void deepcopy_VkPipelineCacheCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCacheCreateInfo* from,
VkPipelineCacheCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pInitialData = nullptr;
if (from->pInitialData)
{
- to->pInitialData = (void*)pool->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
+ to->pInitialData = (void*)alloc->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
}
}
void deepcopy_VkSpecializationMapEntry(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSpecializationMapEntry* from,
VkSpecializationMapEntry* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkSpecializationInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSpecializationInfo* from,
VkSpecializationInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
if (from)
{
to->pMapEntries = nullptr;
if (from->pMapEntries)
{
- to->pMapEntries = (VkSpecializationMapEntry*)pool->alloc(from->mapEntryCount * sizeof(const VkSpecializationMapEntry));
+ 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(pool, from->pMapEntries + i, (VkSpecializationMapEntry*)(to->pMapEntries + i));
+ deepcopy_VkSpecializationMapEntry(alloc, rootType, from->pMapEntries + i, (VkSpecializationMapEntry*)(to->pMapEntries + i));
}
}
}
to->pData = nullptr;
if (from->pData)
{
- to->pData = (void*)pool->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
+ to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
}
}
void deepcopy_VkPipelineShaderStageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineShaderStageCreateInfo* from,
VkPipelineShaderStageCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pName = nullptr;
if (from->pName)
{
- to->pName = pool->strDup(from->pName);
+ to->pName = alloc->strDup(from->pName);
}
to->pSpecializationInfo = nullptr;
if (from->pSpecializationInfo)
{
- to->pSpecializationInfo = (VkSpecializationInfo*)pool->alloc(sizeof(const VkSpecializationInfo));
- deepcopy_VkSpecializationInfo(pool, from->pSpecializationInfo, (VkSpecializationInfo*)(to->pSpecializationInfo));
+ to->pSpecializationInfo = (VkSpecializationInfo*)alloc->alloc(sizeof(const VkSpecializationInfo));
+ deepcopy_VkSpecializationInfo(alloc, rootType, from->pSpecializationInfo, (VkSpecializationInfo*)(to->pSpecializationInfo));
}
}
void deepcopy_VkComputePipelineCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkComputePipelineCreateInfo* from,
VkComputePipelineCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkPipelineShaderStageCreateInfo(pool, &from->stage, (VkPipelineShaderStageCreateInfo*)(&to->stage));
+ deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, &from->stage, (VkPipelineShaderStageCreateInfo*)(&to->stage));
}
void deepcopy_VkVertexInputBindingDescription(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkVertexInputBindingDescription* from,
VkVertexInputBindingDescription* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkVertexInputAttributeDescription(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkVertexInputAttributeDescription* from,
VkVertexInputAttributeDescription* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineVertexInputStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineVertexInputStateCreateInfo* from,
VkPipelineVertexInputStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pVertexBindingDescriptions = nullptr;
if (from->pVertexBindingDescriptions)
{
- to->pVertexBindingDescriptions = (VkVertexInputBindingDescription*)pool->alloc(from->vertexBindingDescriptionCount * sizeof(const VkVertexInputBindingDescription));
+ 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(pool, from->pVertexBindingDescriptions + i, (VkVertexInputBindingDescription*)(to->pVertexBindingDescriptions + i));
+ deepcopy_VkVertexInputBindingDescription(alloc, rootType, from->pVertexBindingDescriptions + i, (VkVertexInputBindingDescription*)(to->pVertexBindingDescriptions + i));
}
}
}
@@ -1217,99 +1448,119 @@
to->pVertexAttributeDescriptions = nullptr;
if (from->pVertexAttributeDescriptions)
{
- to->pVertexAttributeDescriptions = (VkVertexInputAttributeDescription*)pool->alloc(from->vertexAttributeDescriptionCount * sizeof(const VkVertexInputAttributeDescription));
+ 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(pool, from->pVertexAttributeDescriptions + i, (VkVertexInputAttributeDescription*)(to->pVertexAttributeDescriptions + i));
+ deepcopy_VkVertexInputAttributeDescription(alloc, rootType, from->pVertexAttributeDescriptions + i, (VkVertexInputAttributeDescription*)(to->pVertexAttributeDescriptions + i));
}
}
}
}
void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineInputAssemblyStateCreateInfo* from,
VkPipelineInputAssemblyStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineTessellationStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineTessellationStateCreateInfo* from,
VkPipelineTessellationStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkViewport(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkViewport* from,
VkViewport* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineViewportStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportStateCreateInfo* from,
VkPipelineViewportStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pViewports = nullptr;
if (from->pViewports)
{
- to->pViewports = (VkViewport*)pool->alloc(from->viewportCount * sizeof(const VkViewport));
+ 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(pool, from->pViewports + i, (VkViewport*)(to->pViewports + i));
+ deepcopy_VkViewport(alloc, rootType, from->pViewports + i, (VkViewport*)(to->pViewports + i));
}
}
}
@@ -1318,137 +1569,165 @@
to->pScissors = nullptr;
if (from->pScissors)
{
- to->pScissors = (VkRect2D*)pool->alloc(from->scissorCount * sizeof(const VkRect2D));
+ 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(pool, from->pScissors + i, (VkRect2D*)(to->pScissors + i));
+ deepcopy_VkRect2D(alloc, rootType, from->pScissors + i, (VkRect2D*)(to->pScissors + i));
}
}
}
}
void deepcopy_VkPipelineRasterizationStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationStateCreateInfo* from,
VkPipelineRasterizationStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineMultisampleStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineMultisampleStateCreateInfo* from,
VkPipelineMultisampleStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSampleMask = nullptr;
if (from->pSampleMask)
{
- to->pSampleMask = (VkSampleMask*)pool->dupArray(from->pSampleMask, (((from->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+ to->pSampleMask = (VkSampleMask*)alloc->dupArray(from->pSampleMask, (((from->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
}
}
void deepcopy_VkStencilOpState(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkStencilOpState* from,
VkStencilOpState* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineDepthStencilStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineDepthStencilStateCreateInfo* from,
VkPipelineDepthStencilStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkStencilOpState(pool, &from->front, (VkStencilOpState*)(&to->front));
- deepcopy_VkStencilOpState(pool, &from->back, (VkStencilOpState*)(&to->back));
+ deepcopy_VkStencilOpState(alloc, rootType, &from->front, (VkStencilOpState*)(&to->front));
+ deepcopy_VkStencilOpState(alloc, rootType, &from->back, (VkStencilOpState*)(&to->back));
}
void deepcopy_VkPipelineColorBlendAttachmentState(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineColorBlendAttachmentState* from,
VkPipelineColorBlendAttachmentState* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineColorBlendStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineColorBlendStateCreateInfo* from,
VkPipelineColorBlendStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pAttachments = nullptr;
if (from->pAttachments)
{
- to->pAttachments = (VkPipelineColorBlendAttachmentState*)pool->alloc(from->attachmentCount * sizeof(const VkPipelineColorBlendAttachmentState));
+ 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(pool, from->pAttachments + i, (VkPipelineColorBlendAttachmentState*)(to->pAttachments + i));
+ deepcopy_VkPipelineColorBlendAttachmentState(alloc, rootType, from->pAttachments + i, (VkPipelineColorBlendAttachmentState*)(to->pAttachments + i));
}
}
}
@@ -1456,382 +1735,446 @@
}
void deepcopy_VkPipelineDynamicStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineDynamicStateCreateInfo* from,
VkPipelineDynamicStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDynamicStates = nullptr;
if (from->pDynamicStates)
{
- to->pDynamicStates = (VkDynamicState*)pool->dupArray(from->pDynamicStates, from->dynamicStateCount * sizeof(const VkDynamicState));
+ to->pDynamicStates = (VkDynamicState*)alloc->dupArray(from->pDynamicStates, from->dynamicStateCount * sizeof(const VkDynamicState));
}
}
void deepcopy_VkGraphicsPipelineCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGraphicsPipelineCreateInfo* from,
VkGraphicsPipelineCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pStages = nullptr;
if (from->pStages)
{
- to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ 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(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
}
}
}
to->pVertexInputState = nullptr;
if (from->pVertexInputState)
{
- to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)pool->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
- deepcopy_VkPipelineVertexInputStateCreateInfo(pool, from->pVertexInputState, (VkPipelineVertexInputStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineInputAssemblyStateCreateInfo));
- deepcopy_VkPipelineInputAssemblyStateCreateInfo(pool, from->pInputAssemblyState, (VkPipelineInputAssemblyStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
- deepcopy_VkPipelineTessellationStateCreateInfo(pool, from->pTessellationState, (VkPipelineTessellationStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineViewportStateCreateInfo));
- deepcopy_VkPipelineViewportStateCreateInfo(pool, from->pViewportState, (VkPipelineViewportStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineRasterizationStateCreateInfo));
- deepcopy_VkPipelineRasterizationStateCreateInfo(pool, from->pRasterizationState, (VkPipelineRasterizationStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineMultisampleStateCreateInfo));
- deepcopy_VkPipelineMultisampleStateCreateInfo(pool, from->pMultisampleState, (VkPipelineMultisampleStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineDepthStencilStateCreateInfo));
- deepcopy_VkPipelineDepthStencilStateCreateInfo(pool, from->pDepthStencilState, (VkPipelineDepthStencilStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineColorBlendStateCreateInfo));
- deepcopy_VkPipelineColorBlendStateCreateInfo(pool, from->pColorBlendState, (VkPipelineColorBlendStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
- deepcopy_VkPipelineDynamicStateCreateInfo(pool, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
+ to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
+ deepcopy_VkPipelineDynamicStateCreateInfo(alloc, rootType, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
}
}
void deepcopy_VkPushConstantRange(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPushConstantRange* from,
VkPushConstantRange* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineLayoutCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineLayoutCreateInfo* from,
VkPipelineLayoutCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSetLayouts = nullptr;
if (from->pSetLayouts)
{
- to->pSetLayouts = (VkDescriptorSetLayout*)pool->dupArray(from->pSetLayouts, from->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+ to->pSetLayouts = (VkDescriptorSetLayout*)alloc->dupArray(from->pSetLayouts, from->setLayoutCount * sizeof(const VkDescriptorSetLayout));
}
if (from)
{
to->pPushConstantRanges = nullptr;
if (from->pPushConstantRanges)
{
- to->pPushConstantRanges = (VkPushConstantRange*)pool->alloc(from->pushConstantRangeCount * sizeof(const VkPushConstantRange));
+ 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(pool, from->pPushConstantRanges + i, (VkPushConstantRange*)(to->pPushConstantRanges + i));
+ deepcopy_VkPushConstantRange(alloc, rootType, from->pPushConstantRanges + i, (VkPushConstantRange*)(to->pPushConstantRanges + i));
}
}
}
}
void deepcopy_VkSamplerCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerCreateInfo* from,
VkSamplerCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCopyDescriptorSet(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyDescriptorSet* from,
VkCopyDescriptorSet* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDescriptorBufferInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorBufferInfo* from,
VkDescriptorBufferInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkDescriptorImageInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorImageInfo* from,
VkDescriptorImageInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkDescriptorPoolSize(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorPoolSize* from,
VkDescriptorPoolSize* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkDescriptorPoolCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorPoolCreateInfo* from,
VkDescriptorPoolCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pPoolSizes = nullptr;
if (from->pPoolSizes)
{
- to->pPoolSizes = (VkDescriptorPoolSize*)pool->alloc(from->poolSizeCount * sizeof(const VkDescriptorPoolSize));
+ 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(pool, from->pPoolSizes + i, (VkDescriptorPoolSize*)(to->pPoolSizes + i));
+ deepcopy_VkDescriptorPoolSize(alloc, rootType, from->pPoolSizes + i, (VkDescriptorPoolSize*)(to->pPoolSizes + i));
}
}
}
}
void deepcopy_VkDescriptorSetAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetAllocateInfo* from,
VkDescriptorSetAllocateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSetLayouts = nullptr;
if (from->pSetLayouts)
{
- to->pSetLayouts = (VkDescriptorSetLayout*)pool->dupArray(from->pSetLayouts, from->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
+ to->pSetLayouts = (VkDescriptorSetLayout*)alloc->dupArray(from->pSetLayouts, from->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
}
}
void deepcopy_VkDescriptorSetLayoutBinding(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBinding* from,
VkDescriptorSetLayoutBinding* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
to->pImmutableSamplers = nullptr;
if (from->pImmutableSamplers)
{
- to->pImmutableSamplers = (VkSampler*)pool->dupArray(from->pImmutableSamplers, from->descriptorCount * sizeof(const VkSampler));
+ to->pImmutableSamplers = (VkSampler*)alloc->dupArray(from->pImmutableSamplers, from->descriptorCount * sizeof(const VkSampler));
}
}
void deepcopy_VkDescriptorSetLayoutCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetLayoutCreateInfo* from,
VkDescriptorSetLayoutCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pBindings = nullptr;
if (from->pBindings)
{
- to->pBindings = (VkDescriptorSetLayoutBinding*)pool->alloc(from->bindingCount * sizeof(const VkDescriptorSetLayoutBinding));
+ 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(pool, from->pBindings + i, (VkDescriptorSetLayoutBinding*)(to->pBindings + i));
+ deepcopy_VkDescriptorSetLayoutBinding(alloc, rootType, from->pBindings + i, (VkDescriptorSetLayoutBinding*)(to->pBindings + i));
}
}
}
}
void deepcopy_VkWriteDescriptorSet(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWriteDescriptorSet* from,
VkWriteDescriptorSet* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pImageInfo = nullptr;
if (from->pImageInfo)
{
- to->pImageInfo = (VkDescriptorImageInfo*)pool->alloc(from->descriptorCount * sizeof(const VkDescriptorImageInfo));
+ 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(pool, from->pImageInfo + i, (VkDescriptorImageInfo*)(to->pImageInfo + i));
+ deepcopy_VkDescriptorImageInfo(alloc, rootType, from->pImageInfo + i, (VkDescriptorImageInfo*)(to->pImageInfo + i));
}
}
}
@@ -1840,83 +2183,95 @@
to->pBufferInfo = nullptr;
if (from->pBufferInfo)
{
- to->pBufferInfo = (VkDescriptorBufferInfo*)pool->alloc(from->descriptorCount * sizeof(const VkDescriptorBufferInfo));
+ 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(pool, from->pBufferInfo + i, (VkDescriptorBufferInfo*)(to->pBufferInfo + i));
+ deepcopy_VkDescriptorBufferInfo(alloc, rootType, from->pBufferInfo + i, (VkDescriptorBufferInfo*)(to->pBufferInfo + i));
}
}
}
to->pTexelBufferView = nullptr;
if (from->pTexelBufferView)
{
- to->pTexelBufferView = (VkBufferView*)pool->dupArray(from->pTexelBufferView, from->descriptorCount * sizeof(const VkBufferView));
+ to->pTexelBufferView = (VkBufferView*)alloc->dupArray(from->pTexelBufferView, from->descriptorCount * sizeof(const VkBufferView));
}
}
void deepcopy_VkAttachmentDescription(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentDescription* from,
VkAttachmentDescription* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkAttachmentReference(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentReference* from,
VkAttachmentReference* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkFramebufferCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFramebufferCreateInfo* from,
VkFramebufferCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAttachments = nullptr;
if (from->pAttachments)
{
- to->pAttachments = (VkImageView*)pool->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
+ to->pAttachments = (VkImageView*)alloc->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
}
}
void deepcopy_VkSubpassDescription(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDescription* from,
VkSubpassDescription* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
if (from)
{
to->pInputAttachments = nullptr;
if (from->pInputAttachments)
{
- to->pInputAttachments = (VkAttachmentReference*)pool->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference));
+ 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(pool, from->pInputAttachments + i, (VkAttachmentReference*)(to->pInputAttachments + i));
+ deepcopy_VkAttachmentReference(alloc, rootType, from->pInputAttachments + i, (VkAttachmentReference*)(to->pInputAttachments + i));
}
}
}
@@ -1925,11 +2280,11 @@
to->pColorAttachments = nullptr;
if (from->pColorAttachments)
{
- to->pColorAttachments = (VkAttachmentReference*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference));
+ 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(pool, from->pColorAttachments + i, (VkAttachmentReference*)(to->pColorAttachments + i));
+ deepcopy_VkAttachmentReference(alloc, rootType, from->pColorAttachments + i, (VkAttachmentReference*)(to->pColorAttachments + i));
}
}
}
@@ -1938,66 +2293,74 @@
to->pResolveAttachments = nullptr;
if (from->pResolveAttachments)
{
- to->pResolveAttachments = (VkAttachmentReference*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference));
+ 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(pool, from->pResolveAttachments + i, (VkAttachmentReference*)(to->pResolveAttachments + i));
+ deepcopy_VkAttachmentReference(alloc, rootType, from->pResolveAttachments + i, (VkAttachmentReference*)(to->pResolveAttachments + i));
}
}
}
to->pDepthStencilAttachment = nullptr;
if (from->pDepthStencilAttachment)
{
- to->pDepthStencilAttachment = (VkAttachmentReference*)pool->alloc(sizeof(const VkAttachmentReference));
- deepcopy_VkAttachmentReference(pool, from->pDepthStencilAttachment, (VkAttachmentReference*)(to->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*)pool->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
+ to->pPreserveAttachments = (uint32_t*)alloc->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
}
}
void deepcopy_VkSubpassDependency(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDependency* from,
VkSubpassDependency* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkRenderPassCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassCreateInfo* from,
VkRenderPassCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pAttachments = nullptr;
if (from->pAttachments)
{
- to->pAttachments = (VkAttachmentDescription*)pool->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription));
+ 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(pool, from->pAttachments + i, (VkAttachmentDescription*)(to->pAttachments + i));
+ deepcopy_VkAttachmentDescription(alloc, rootType, from->pAttachments + i, (VkAttachmentDescription*)(to->pAttachments + i));
}
}
}
@@ -2006,11 +2369,11 @@
to->pSubpasses = nullptr;
if (from->pSubpasses)
{
- to->pSubpasses = (VkSubpassDescription*)pool->alloc(from->subpassCount * sizeof(const VkSubpassDescription));
+ 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(pool, from->pSubpasses + i, (VkSubpassDescription*)(to->pSubpasses + i));
+ deepcopy_VkSubpassDescription(alloc, rootType, from->pSubpasses + i, (VkSubpassDescription*)(to->pSubpasses + i));
}
}
}
@@ -2019,146 +2382,178 @@
to->pDependencies = nullptr;
if (from->pDependencies)
{
- to->pDependencies = (VkSubpassDependency*)pool->alloc(from->dependencyCount * sizeof(const VkSubpassDependency));
+ 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(pool, from->pDependencies + i, (VkSubpassDependency*)(to->pDependencies + i));
+ deepcopy_VkSubpassDependency(alloc, rootType, from->pDependencies + i, (VkSubpassDependency*)(to->pDependencies + i));
}
}
}
}
void deepcopy_VkCommandPoolCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandPoolCreateInfo* from,
VkCommandPoolCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferAllocateInfo* from,
VkCommandBufferAllocateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferInheritanceInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferInheritanceInfo* from,
VkCommandBufferInheritanceInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferBeginInfo* from,
VkCommandBufferBeginInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pInheritanceInfo = nullptr;
if (from->pInheritanceInfo)
{
- to->pInheritanceInfo = (VkCommandBufferInheritanceInfo*)pool->alloc(sizeof(const VkCommandBufferInheritanceInfo));
- deepcopy_VkCommandBufferInheritanceInfo(pool, from->pInheritanceInfo, (VkCommandBufferInheritanceInfo*)(to->pInheritanceInfo));
+ to->pInheritanceInfo = (VkCommandBufferInheritanceInfo*)alloc->alloc(sizeof(const VkCommandBufferInheritanceInfo));
+ deepcopy_VkCommandBufferInheritanceInfo(alloc, rootType, from->pInheritanceInfo, (VkCommandBufferInheritanceInfo*)(to->pInheritanceInfo));
}
}
void deepcopy_VkBufferCopy(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferCopy* from,
VkBufferCopy* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkImageSubresourceLayers(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSubresourceLayers* from,
VkImageSubresourceLayers* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkBufferImageCopy(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferImageCopy* from,
VkBufferImageCopy* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkImageSubresourceLayers(pool, &from->imageSubresource, (VkImageSubresourceLayers*)(&to->imageSubresource));
- deepcopy_VkOffset3D(pool, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
- deepcopy_VkExtent3D(pool, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+ 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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearColorValue* from,
VkClearColorValue* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
memcpy(to->float32, from->float32, 4 * sizeof(float));
memcpy(to->int32, from->int32, 4 * sizeof(int32_t));
@@ -2166,123 +2561,143 @@
}
void deepcopy_VkClearDepthStencilValue(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearDepthStencilValue* from,
VkClearDepthStencilValue* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkClearValue(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearValue* from,
VkClearValue* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkClearColorValue(pool, &from->color, (VkClearColorValue*)(&to->color));
- deepcopy_VkClearDepthStencilValue(pool, &from->depthStencil, (VkClearDepthStencilValue*)(&to->depthStencil));
+ deepcopy_VkClearColorValue(alloc, rootType, &from->color, (VkClearColorValue*)(&to->color));
+ deepcopy_VkClearDepthStencilValue(alloc, rootType, &from->depthStencil, (VkClearDepthStencilValue*)(&to->depthStencil));
}
void deepcopy_VkClearAttachment(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearAttachment* from,
VkClearAttachment* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkClearValue(pool, &from->clearValue, (VkClearValue*)(&to->clearValue));
+ deepcopy_VkClearValue(alloc, rootType, &from->clearValue, (VkClearValue*)(&to->clearValue));
}
void deepcopy_VkClearRect(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearRect* from,
VkClearRect* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkRect2D(pool, &from->rect, (VkRect2D*)(&to->rect));
+ deepcopy_VkRect2D(alloc, rootType, &from->rect, (VkRect2D*)(&to->rect));
}
void deepcopy_VkImageBlit(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageBlit* from,
VkImageBlit* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- deepcopy_VkOffset3D(pool, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
+ deepcopy_VkOffset3D(alloc, rootType, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
}
- deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- deepcopy_VkOffset3D(pool, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
+ deepcopy_VkOffset3D(alloc, rootType, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
}
}
void deepcopy_VkImageCopy(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageCopy* from,
VkImageCopy* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
- deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
- deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
- deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
- deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+ 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_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
+ deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
void deepcopy_VkImageResolve(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageResolve* from,
VkImageResolve* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
- deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
- deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
- deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
- deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+ 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_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
+ deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
void deepcopy_VkRenderPassBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassBeginInfo* from,
VkRenderPassBeginInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkRect2D(pool, &from->renderArea, (VkRect2D*)(&to->renderArea));
+ deepcopy_VkRect2D(alloc, rootType, &from->renderArea, (VkRect2D*)(&to->renderArea));
if (from)
{
to->pClearValues = nullptr;
if (from->pClearValues)
{
- to->pClearValues = (VkClearValue*)pool->alloc(from->clearValueCount * sizeof(const VkClearValue));
+ 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(pool, from->pClearValues + i, (VkClearValue*)(to->pClearValues + i));
+ deepcopy_VkClearValue(alloc, rootType, from->pClearValues + i, (VkClearValue*)(to->pClearValues + i));
}
}
}
@@ -2291,1305 +2706,1629 @@
#endif
#ifdef VK_VERSION_1_1
void deepcopy_VkPhysicalDeviceSubgroupProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupProperties* from,
VkPhysicalDeviceSubgroupProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBindBufferMemoryInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindBufferMemoryInfo* from,
VkBindBufferMemoryInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBindImageMemoryInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindImageMemoryInfo* from,
VkBindImageMemoryInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDevice16BitStorageFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevice16BitStorageFeatures* from,
VkPhysicalDevice16BitStorageFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryDedicatedRequirements(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryDedicatedRequirements* from,
VkMemoryDedicatedRequirements* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryDedicatedAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryDedicatedAllocateInfo* from,
VkMemoryDedicatedAllocateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryAllocateFlagsInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryAllocateFlagsInfo* from,
VkMemoryAllocateFlagsInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceGroupRenderPassBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupRenderPassBeginInfo* from,
VkDeviceGroupRenderPassBeginInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pDeviceRenderAreas = nullptr;
if (from->pDeviceRenderAreas)
{
- to->pDeviceRenderAreas = (VkRect2D*)pool->alloc(from->deviceRenderAreaCount * sizeof(const VkRect2D));
+ 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(pool, from->pDeviceRenderAreas + i, (VkRect2D*)(to->pDeviceRenderAreas + i));
+ deepcopy_VkRect2D(alloc, rootType, from->pDeviceRenderAreas + i, (VkRect2D*)(to->pDeviceRenderAreas + i));
}
}
}
}
void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupCommandBufferBeginInfo* from,
VkDeviceGroupCommandBufferBeginInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceGroupSubmitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupSubmitInfo* from,
VkDeviceGroupSubmitInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pWaitSemaphoreDeviceIndices, from->waitSemaphoreCount * sizeof(const uint32_t));
+ to->pWaitSemaphoreDeviceIndices = (uint32_t*)alloc->dupArray(from->pWaitSemaphoreDeviceIndices, from->waitSemaphoreCount * sizeof(const uint32_t));
}
to->pCommandBufferDeviceMasks = nullptr;
if (from->pCommandBufferDeviceMasks)
{
- to->pCommandBufferDeviceMasks = (uint32_t*)pool->dupArray(from->pCommandBufferDeviceMasks, from->commandBufferCount * sizeof(const uint32_t));
+ to->pCommandBufferDeviceMasks = (uint32_t*)alloc->dupArray(from->pCommandBufferDeviceMasks, from->commandBufferCount * sizeof(const uint32_t));
}
to->pSignalSemaphoreDeviceIndices = nullptr;
if (from->pSignalSemaphoreDeviceIndices)
{
- to->pSignalSemaphoreDeviceIndices = (uint32_t*)pool->dupArray(from->pSignalSemaphoreDeviceIndices, from->signalSemaphoreCount * sizeof(const uint32_t));
+ to->pSignalSemaphoreDeviceIndices = (uint32_t*)alloc->dupArray(from->pSignalSemaphoreDeviceIndices, from->signalSemaphoreCount * sizeof(const uint32_t));
}
}
void deepcopy_VkDeviceGroupBindSparseInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupBindSparseInfo* from,
VkDeviceGroupBindSparseInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindBufferMemoryDeviceGroupInfo* from,
VkBindBufferMemoryDeviceGroupInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
+ to->pDeviceIndices = (uint32_t*)alloc->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkBindImageMemoryDeviceGroupInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindImageMemoryDeviceGroupInfo* from,
VkBindImageMemoryDeviceGroupInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
+ to->pDeviceIndices = (uint32_t*)alloc->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
}
if (from)
{
to->pSplitInstanceBindRegions = nullptr;
if (from->pSplitInstanceBindRegions)
{
- to->pSplitInstanceBindRegions = (VkRect2D*)pool->alloc(from->splitInstanceBindRegionCount * sizeof(const VkRect2D));
+ 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(pool, from->pSplitInstanceBindRegions + i, (VkRect2D*)(to->pSplitInstanceBindRegions + i));
+ deepcopy_VkRect2D(alloc, rootType, from->pSplitInstanceBindRegions + i, (VkRect2D*)(to->pSplitInstanceBindRegions + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceGroupProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceGroupProperties* from,
VkPhysicalDeviceGroupProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ 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));
}
void deepcopy_VkDeviceGroupDeviceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupDeviceCreateInfo* from,
VkDeviceGroupDeviceCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pPhysicalDevices = nullptr;
if (from->pPhysicalDevices)
{
- to->pPhysicalDevices = (VkPhysicalDevice*)pool->dupArray(from->pPhysicalDevices, from->physicalDeviceCount * sizeof(const VkPhysicalDevice));
+ to->pPhysicalDevices = (VkPhysicalDevice*)alloc->dupArray(from->pPhysicalDevices, from->physicalDeviceCount * sizeof(const VkPhysicalDevice));
}
}
void deepcopy_VkBufferMemoryRequirementsInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferMemoryRequirementsInfo2* from,
VkBufferMemoryRequirementsInfo2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkImageMemoryRequirementsInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageMemoryRequirementsInfo2* from,
VkImageMemoryRequirementsInfo2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkImageSparseMemoryRequirementsInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSparseMemoryRequirementsInfo2* from,
VkImageSparseMemoryRequirementsInfo2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryRequirements2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryRequirements2* from,
VkMemoryRequirements2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkMemoryRequirements(pool, &from->memoryRequirements, (VkMemoryRequirements*)(&to->memoryRequirements));
+ deepcopy_VkMemoryRequirements(alloc, rootType, &from->memoryRequirements, (VkMemoryRequirements*)(&to->memoryRequirements));
}
void deepcopy_VkSparseImageMemoryRequirements2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements2* from,
VkSparseImageMemoryRequirements2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSparseImageMemoryRequirements(pool, &from->memoryRequirements, (VkSparseImageMemoryRequirements*)(&to->memoryRequirements));
+ deepcopy_VkSparseImageMemoryRequirements(alloc, rootType, &from->memoryRequirements, (VkSparseImageMemoryRequirements*)(&to->memoryRequirements));
}
void deepcopy_VkPhysicalDeviceFeatures2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures2* from,
VkPhysicalDeviceFeatures2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkPhysicalDeviceFeatures(pool, &from->features, (VkPhysicalDeviceFeatures*)(&to->features));
+ deepcopy_VkPhysicalDeviceFeatures(alloc, rootType, &from->features, (VkPhysicalDeviceFeatures*)(&to->features));
}
void deepcopy_VkPhysicalDeviceProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceProperties2* from,
VkPhysicalDeviceProperties2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkPhysicalDeviceProperties(pool, &from->properties, (VkPhysicalDeviceProperties*)(&to->properties));
+ deepcopy_VkPhysicalDeviceProperties(alloc, rootType, &from->properties, (VkPhysicalDeviceProperties*)(&to->properties));
}
void deepcopy_VkFormatProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFormatProperties2* from,
VkFormatProperties2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkFormatProperties(pool, &from->formatProperties, (VkFormatProperties*)(&to->formatProperties));
+ deepcopy_VkFormatProperties(alloc, rootType, &from->formatProperties, (VkFormatProperties*)(&to->formatProperties));
}
void deepcopy_VkImageFormatProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageFormatProperties2* from,
VkImageFormatProperties2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageFormatProperties(pool, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
+ deepcopy_VkImageFormatProperties(alloc, rootType, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
}
void deepcopy_VkPhysicalDeviceImageFormatInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImageFormatInfo2* from,
VkPhysicalDeviceImageFormatInfo2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkQueueFamilyProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueueFamilyProperties2* from,
VkQueueFamilyProperties2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkQueueFamilyProperties(pool, &from->queueFamilyProperties, (VkQueueFamilyProperties*)(&to->queueFamilyProperties));
+ deepcopy_VkQueueFamilyProperties(alloc, rootType, &from->queueFamilyProperties, (VkQueueFamilyProperties*)(&to->queueFamilyProperties));
}
void deepcopy_VkPhysicalDeviceMemoryProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties2* from,
VkPhysicalDeviceMemoryProperties2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkPhysicalDeviceMemoryProperties(pool, &from->memoryProperties, (VkPhysicalDeviceMemoryProperties*)(&to->memoryProperties));
+ deepcopy_VkPhysicalDeviceMemoryProperties(alloc, rootType, &from->memoryProperties, (VkPhysicalDeviceMemoryProperties*)(&to->memoryProperties));
}
void deepcopy_VkSparseImageFormatProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageFormatProperties2* from,
VkSparseImageFormatProperties2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSparseImageFormatProperties(pool, &from->properties, (VkSparseImageFormatProperties*)(&to->properties));
+ deepcopy_VkSparseImageFormatProperties(alloc, rootType, &from->properties, (VkSparseImageFormatProperties*)(&to->properties));
}
void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseImageFormatInfo2* from,
VkPhysicalDeviceSparseImageFormatInfo2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDevicePointClippingProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePointClippingProperties* from,
VkPhysicalDevicePointClippingProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkInputAttachmentAspectReference(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkInputAttachmentAspectReference* from,
VkInputAttachmentAspectReference* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* from,
VkRenderPassInputAttachmentAspectCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pAspectReferences = nullptr;
if (from->pAspectReferences)
{
- to->pAspectReferences = (VkInputAttachmentAspectReference*)pool->alloc(from->aspectReferenceCount * sizeof(const VkInputAttachmentAspectReference));
+ 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(pool, from->pAspectReferences + i, (VkInputAttachmentAspectReference*)(to->pAspectReferences + i));
+ deepcopy_VkInputAttachmentAspectReference(alloc, rootType, from->pAspectReferences + i, (VkInputAttachmentAspectReference*)(to->pAspectReferences + i));
}
}
}
}
void deepcopy_VkImageViewUsageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewUsageCreateInfo* from,
VkImageViewUsageCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* from,
VkPipelineTessellationDomainOriginStateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkRenderPassMultiviewCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassMultiviewCreateInfo* from,
VkRenderPassMultiviewCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pViewMasks, from->subpassCount * sizeof(const uint32_t));
+ to->pViewMasks = (uint32_t*)alloc->dupArray(from->pViewMasks, from->subpassCount * sizeof(const uint32_t));
}
to->pViewOffsets = nullptr;
if (from->pViewOffsets)
{
- to->pViewOffsets = (int32_t*)pool->dupArray(from->pViewOffsets, from->dependencyCount * sizeof(const int32_t));
+ to->pViewOffsets = (int32_t*)alloc->dupArray(from->pViewOffsets, from->dependencyCount * sizeof(const int32_t));
}
to->pCorrelationMasks = nullptr;
if (from->pCorrelationMasks)
{
- to->pCorrelationMasks = (uint32_t*)pool->dupArray(from->pCorrelationMasks, from->correlationMaskCount * sizeof(const uint32_t));
+ to->pCorrelationMasks = (uint32_t*)alloc->dupArray(from->pCorrelationMasks, from->correlationMaskCount * sizeof(const uint32_t));
}
}
void deepcopy_VkPhysicalDeviceMultiviewFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewFeatures* from,
VkPhysicalDeviceMultiviewFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceMultiviewProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewProperties* from,
VkPhysicalDeviceMultiviewProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceVariablePointersFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* from,
VkPhysicalDeviceVariablePointersFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryFeatures* from,
VkPhysicalDeviceProtectedMemoryFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* from,
VkPhysicalDeviceProtectedMemoryProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceQueueInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceQueueInfo2* from,
VkDeviceQueueInfo2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkProtectedSubmitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkProtectedSubmitInfo* from,
VkProtectedSubmitInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSamplerYcbcrConversionCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionCreateInfo* from,
VkSamplerYcbcrConversionCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkComponentMapping(pool, &from->components, (VkComponentMapping*)(&to->components));
+ deepcopy_VkComponentMapping(alloc, rootType, &from->components, (VkComponentMapping*)(&to->components));
}
void deepcopy_VkSamplerYcbcrConversionInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionInfo* from,
VkSamplerYcbcrConversionInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBindImagePlaneMemoryInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindImagePlaneMemoryInfo* from,
VkBindImagePlaneMemoryInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkImagePlaneMemoryRequirementsInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImagePlaneMemoryRequirementsInfo* from,
VkImagePlaneMemoryRequirementsInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
VkPhysicalDeviceSamplerYcbcrConversionFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* from,
VkSamplerYcbcrConversionImageFormatProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDescriptorUpdateTemplateEntry(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateEntry* from,
VkDescriptorUpdateTemplateEntry* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateCreateInfo* from,
VkDescriptorUpdateTemplateCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pDescriptorUpdateEntries = nullptr;
if (from->pDescriptorUpdateEntries)
{
- to->pDescriptorUpdateEntries = (VkDescriptorUpdateTemplateEntry*)pool->alloc(from->descriptorUpdateEntryCount * sizeof(const VkDescriptorUpdateTemplateEntry));
+ 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(pool, from->pDescriptorUpdateEntries + i, (VkDescriptorUpdateTemplateEntry*)(to->pDescriptorUpdateEntries + i));
+ deepcopy_VkDescriptorUpdateTemplateEntry(alloc, rootType, from->pDescriptorUpdateEntries + i, (VkDescriptorUpdateTemplateEntry*)(to->pDescriptorUpdateEntries + i));
}
}
}
}
void deepcopy_VkExternalMemoryProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalMemoryProperties* from,
VkExternalMemoryProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalImageFormatInfo* from,
VkPhysicalDeviceExternalImageFormatInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExternalImageFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalImageFormatProperties* from,
VkExternalImageFormatProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExternalMemoryProperties(pool, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
+ deepcopy_VkExternalMemoryProperties(alloc, rootType, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
}
void deepcopy_VkPhysicalDeviceExternalBufferInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalBufferInfo* from,
VkPhysicalDeviceExternalBufferInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExternalBufferProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalBufferProperties* from,
VkExternalBufferProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExternalMemoryProperties(pool, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
+ deepcopy_VkExternalMemoryProperties(alloc, rootType, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
}
void deepcopy_VkPhysicalDeviceIDProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceIDProperties* from,
VkPhysicalDeviceIDProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->deviceUUID, from->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
memcpy(to->driverUUID, from->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
@@ -3597,312 +4336,396 @@
}
void deepcopy_VkExternalMemoryImageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfo* from,
VkExternalMemoryImageCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExternalMemoryBufferCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalMemoryBufferCreateInfo* from,
VkExternalMemoryBufferCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExportMemoryAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfo* from,
VkExportMemoryAllocateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceExternalFenceInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalFenceInfo* from,
VkPhysicalDeviceExternalFenceInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExternalFenceProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalFenceProperties* from,
VkExternalFenceProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExportFenceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportFenceCreateInfo* from,
VkExportFenceCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExportSemaphoreCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportSemaphoreCreateInfo* from,
VkExportSemaphoreCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalSemaphoreInfo* from,
VkPhysicalDeviceExternalSemaphoreInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExternalSemaphoreProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalSemaphoreProperties* from,
VkExternalSemaphoreProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceMaintenance3Properties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMaintenance3Properties* from,
VkPhysicalDeviceMaintenance3Properties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDescriptorSetLayoutSupport(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetLayoutSupport* from,
VkDescriptorSetLayoutSupport* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* from,
VkPhysicalDeviceShaderDrawParametersFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_VERSION_1_2
void deepcopy_VkPhysicalDeviceVulkan11Features(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Features* from,
VkPhysicalDeviceVulkan11Features* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceVulkan11Properties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Properties* from,
VkPhysicalDeviceVulkan11Properties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->deviceUUID, from->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
memcpy(to->driverUUID, from->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
@@ -3910,162 +4733,200 @@
}
void deepcopy_VkPhysicalDeviceVulkan12Features(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Features* from,
VkPhysicalDeviceVulkan12Features* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkConformanceVersion(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkConformanceVersion* from,
VkConformanceVersion* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPhysicalDeviceVulkan12Properties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Properties* from,
VkPhysicalDeviceVulkan12Properties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ 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(pool, &from->conformanceVersion, (VkConformanceVersion*)(&to->conformanceVersion));
+ deepcopy_VkConformanceVersion(alloc, rootType, &from->conformanceVersion, (VkConformanceVersion*)(&to->conformanceVersion));
}
void deepcopy_VkImageFormatListCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageFormatListCreateInfo* from,
VkImageFormatListCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pViewFormats = nullptr;
if (from->pViewFormats)
{
- to->pViewFormats = (VkFormat*)pool->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
+ to->pViewFormats = (VkFormat*)alloc->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
}
}
void deepcopy_VkAttachmentDescription2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentDescription2* from,
VkAttachmentDescription2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAttachmentReference2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentReference2* from,
VkAttachmentReference2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSubpassDescription2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDescription2* from,
VkSubpassDescription2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pInputAttachments = nullptr;
if (from->pInputAttachments)
{
- to->pInputAttachments = (VkAttachmentReference2*)pool->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference2));
+ 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(pool, from->pInputAttachments + i, (VkAttachmentReference2*)(to->pInputAttachments + i));
+ deepcopy_VkAttachmentReference2(alloc, rootType, from->pInputAttachments + i, (VkAttachmentReference2*)(to->pInputAttachments + i));
}
}
}
@@ -4074,11 +4935,11 @@
to->pColorAttachments = nullptr;
if (from->pColorAttachments)
{
- to->pColorAttachments = (VkAttachmentReference2*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2));
+ 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(pool, from->pColorAttachments + i, (VkAttachmentReference2*)(to->pColorAttachments + i));
+ deepcopy_VkAttachmentReference2(alloc, rootType, from->pColorAttachments + i, (VkAttachmentReference2*)(to->pColorAttachments + i));
}
}
}
@@ -4087,79 +4948,91 @@
to->pResolveAttachments = nullptr;
if (from->pResolveAttachments)
{
- to->pResolveAttachments = (VkAttachmentReference2*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2));
+ 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(pool, from->pResolveAttachments + i, (VkAttachmentReference2*)(to->pResolveAttachments + i));
+ deepcopy_VkAttachmentReference2(alloc, rootType, from->pResolveAttachments + i, (VkAttachmentReference2*)(to->pResolveAttachments + i));
}
}
}
to->pDepthStencilAttachment = nullptr;
if (from->pDepthStencilAttachment)
{
- to->pDepthStencilAttachment = (VkAttachmentReference2*)pool->alloc(sizeof(const VkAttachmentReference2));
- deepcopy_VkAttachmentReference2(pool, from->pDepthStencilAttachment, (VkAttachmentReference2*)(to->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*)pool->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
+ to->pPreserveAttachments = (uint32_t*)alloc->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
}
}
void deepcopy_VkSubpassDependency2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDependency2* from,
VkSubpassDependency2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkRenderPassCreateInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassCreateInfo2* from,
VkRenderPassCreateInfo2* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pAttachments = nullptr;
if (from->pAttachments)
{
- to->pAttachments = (VkAttachmentDescription2*)pool->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription2));
+ 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(pool, from->pAttachments + i, (VkAttachmentDescription2*)(to->pAttachments + i));
+ deepcopy_VkAttachmentDescription2(alloc, rootType, from->pAttachments + i, (VkAttachmentDescription2*)(to->pAttachments + i));
}
}
}
@@ -4168,11 +5041,11 @@
to->pSubpasses = nullptr;
if (from->pSubpasses)
{
- to->pSubpasses = (VkSubpassDescription2*)pool->alloc(from->subpassCount * sizeof(const VkSubpassDescription2));
+ 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(pool, from->pSubpasses + i, (VkSubpassDescription2*)(to->pSubpasses + i));
+ deepcopy_VkSubpassDescription2(alloc, rootType, from->pSubpasses + i, (VkSubpassDescription2*)(to->pSubpasses + i));
}
}
}
@@ -4181,1474 +5054,1824 @@
to->pDependencies = nullptr;
if (from->pDependencies)
{
- to->pDependencies = (VkSubpassDependency2*)pool->alloc(from->dependencyCount * sizeof(const VkSubpassDependency2));
+ 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(pool, from->pDependencies + i, (VkSubpassDependency2*)(to->pDependencies + i));
+ deepcopy_VkSubpassDependency2(alloc, rootType, from->pDependencies + i, (VkSubpassDependency2*)(to->pDependencies + i));
}
}
}
to->pCorrelatedViewMasks = nullptr;
if (from->pCorrelatedViewMasks)
{
- to->pCorrelatedViewMasks = (uint32_t*)pool->dupArray(from->pCorrelatedViewMasks, from->correlatedViewMaskCount * sizeof(const uint32_t));
+ to->pCorrelatedViewMasks = (uint32_t*)alloc->dupArray(from->pCorrelatedViewMasks, from->correlatedViewMaskCount * sizeof(const uint32_t));
}
}
void deepcopy_VkSubpassBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassBeginInfo* from,
VkSubpassBeginInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSubpassEndInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassEndInfo* from,
VkSubpassEndInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDevice8BitStorageFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevice8BitStorageFeatures* from,
VkPhysicalDevice8BitStorageFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceDriverProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDriverProperties* from,
VkPhysicalDeviceDriverProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ 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(pool, &from->conformanceVersion, (VkConformanceVersion*)(&to->conformanceVersion));
+ deepcopy_VkConformanceVersion(alloc, rootType, &from->conformanceVersion, (VkConformanceVersion*)(&to->conformanceVersion));
}
void deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicInt64Features* from,
VkPhysicalDeviceShaderAtomicInt64Features* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* from,
VkPhysicalDeviceShaderFloat16Int8Features* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFloatControlsProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFloatControlsProperties* from,
VkPhysicalDeviceFloatControlsProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* from,
VkDescriptorSetLayoutBindingFlagsCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pBindingFlags = nullptr;
if (from->pBindingFlags)
{
- to->pBindingFlags = (VkDescriptorBindingFlags*)pool->dupArray(from->pBindingFlags, from->bindingCount * sizeof(const VkDescriptorBindingFlags));
+ to->pBindingFlags = (VkDescriptorBindingFlags*)alloc->dupArray(from->pBindingFlags, from->bindingCount * sizeof(const VkDescriptorBindingFlags));
}
}
void deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* from,
VkPhysicalDeviceDescriptorIndexingFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* from,
VkPhysicalDeviceDescriptorIndexingProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* from,
VkDescriptorSetVariableDescriptorCountAllocateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pDescriptorCounts, from->descriptorSetCount * sizeof(const uint32_t));
+ to->pDescriptorCounts = (uint32_t*)alloc->dupArray(from->pDescriptorCounts, from->descriptorSetCount * sizeof(const uint32_t));
}
}
void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* from,
VkDescriptorSetVariableDescriptorCountLayoutSupport* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSubpassDescriptionDepthStencilResolve(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDescriptionDepthStencilResolve* from,
VkSubpassDescriptionDepthStencilResolve* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDepthStencilResolveAttachment = nullptr;
if (from->pDepthStencilResolveAttachment)
{
- to->pDepthStencilResolveAttachment = (VkAttachmentReference2*)pool->alloc(sizeof(const VkAttachmentReference2));
- deepcopy_VkAttachmentReference2(pool, from->pDepthStencilResolveAttachment, (VkAttachmentReference2*)(to->pDepthStencilResolveAttachment));
+ to->pDepthStencilResolveAttachment = (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
+ deepcopy_VkAttachmentReference2(alloc, rootType, from->pDepthStencilResolveAttachment, (VkAttachmentReference2*)(to->pDepthStencilResolveAttachment));
}
}
void deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* from,
VkPhysicalDeviceDepthStencilResolveProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* from,
VkPhysicalDeviceScalarBlockLayoutFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkImageStencilUsageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageStencilUsageCreateInfo* from,
VkImageStencilUsageCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSamplerReductionModeCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerReductionModeCreateInfo* from,
VkSamplerReductionModeCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* from,
VkPhysicalDeviceSamplerFilterMinmaxProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* from,
VkPhysicalDeviceVulkanMemoryModelFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* from,
VkPhysicalDeviceImagelessFramebufferFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkFramebufferAttachmentImageInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFramebufferAttachmentImageInfo* from,
VkFramebufferAttachmentImageInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pViewFormats = nullptr;
if (from->pViewFormats)
{
- to->pViewFormats = (VkFormat*)pool->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
+ to->pViewFormats = (VkFormat*)alloc->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
}
}
void deepcopy_VkFramebufferAttachmentsCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFramebufferAttachmentsCreateInfo* from,
VkFramebufferAttachmentsCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pAttachmentImageInfos = nullptr;
if (from->pAttachmentImageInfos)
{
- to->pAttachmentImageInfos = (VkFramebufferAttachmentImageInfo*)pool->alloc(from->attachmentImageInfoCount * sizeof(const VkFramebufferAttachmentImageInfo));
+ 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(pool, from->pAttachmentImageInfos + i, (VkFramebufferAttachmentImageInfo*)(to->pAttachmentImageInfos + i));
+ deepcopy_VkFramebufferAttachmentImageInfo(alloc, rootType, from->pAttachmentImageInfos + i, (VkFramebufferAttachmentImageInfo*)(to->pAttachmentImageInfos + i));
}
}
}
}
void deepcopy_VkRenderPassAttachmentBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassAttachmentBeginInfo* from,
VkRenderPassAttachmentBeginInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAttachments = nullptr;
if (from->pAttachments)
{
- to->pAttachments = (VkImageView*)pool->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
+ to->pAttachments = (VkImageView*)alloc->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
}
}
void deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* from,
VkPhysicalDeviceUniformBufferStandardLayoutFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* from,
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* from,
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAttachmentReferenceStencilLayout(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentReferenceStencilLayout* from,
VkAttachmentReferenceStencilLayout* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAttachmentDescriptionStencilLayout(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentDescriptionStencilLayout* from,
VkAttachmentDescriptionStencilLayout* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceHostQueryResetFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceHostQueryResetFeatures* from,
VkPhysicalDeviceHostQueryResetFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* from,
VkPhysicalDeviceTimelineSemaphoreFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* from,
VkPhysicalDeviceTimelineSemaphoreProperties* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSemaphoreTypeCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreTypeCreateInfo* from,
VkSemaphoreTypeCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkTimelineSemaphoreSubmitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkTimelineSemaphoreSubmitInfo* from,
VkTimelineSemaphoreSubmitInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValueCount * sizeof(const uint64_t));
+ to->pWaitSemaphoreValues = (uint64_t*)alloc->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValueCount * sizeof(const uint64_t));
}
to->pSignalSemaphoreValues = nullptr;
if (from->pSignalSemaphoreValues)
{
- to->pSignalSemaphoreValues = (uint64_t*)pool->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValueCount * sizeof(const uint64_t));
+ to->pSignalSemaphoreValues = (uint64_t*)alloc->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValueCount * sizeof(const uint64_t));
}
}
void deepcopy_VkSemaphoreWaitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreWaitInfo* from,
VkSemaphoreWaitInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSemaphores = nullptr;
if (from->pSemaphores)
{
- to->pSemaphores = (VkSemaphore*)pool->dupArray(from->pSemaphores, from->semaphoreCount * sizeof(const VkSemaphore));
+ to->pSemaphores = (VkSemaphore*)alloc->dupArray(from->pSemaphores, from->semaphoreCount * sizeof(const VkSemaphore));
}
to->pValues = nullptr;
if (from->pValues)
{
- to->pValues = (uint64_t*)pool->dupArray(from->pValues, from->semaphoreCount * sizeof(const uint64_t));
+ to->pValues = (uint64_t*)alloc->dupArray(from->pValues, from->semaphoreCount * sizeof(const uint64_t));
}
}
void deepcopy_VkSemaphoreSignalInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreSignalInfo* from,
VkSemaphoreSignalInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* from,
VkPhysicalDeviceBufferDeviceAddressFeatures* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBufferDeviceAddressInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferDeviceAddressInfo* from,
VkBufferDeviceAddressInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferOpaqueCaptureAddressCreateInfo* from,
VkBufferOpaqueCaptureAddressCreateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* from,
VkMemoryOpaqueCaptureAddressAllocateInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* from,
VkDeviceMemoryOpaqueCaptureAddressInfo* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_surface
void deepcopy_VkSurfaceCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesKHR* from,
VkSurfaceCapabilitiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkExtent2D(pool, &from->currentExtent, (VkExtent2D*)(&to->currentExtent));
- deepcopy_VkExtent2D(pool, &from->minImageExtent, (VkExtent2D*)(&to->minImageExtent));
- deepcopy_VkExtent2D(pool, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->currentExtent, (VkExtent2D*)(&to->currentExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->minImageExtent, (VkExtent2D*)(&to->minImageExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
}
void deepcopy_VkSurfaceFormatKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceFormatKHR* from,
VkSurfaceFormatKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
#endif
#ifdef VK_KHR_swapchain
void deepcopy_VkSwapchainCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSwapchainCreateInfoKHR* from,
VkSwapchainCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
to->pQueueFamilyIndices = nullptr;
if (from->pQueueFamilyIndices)
{
- to->pQueueFamilyIndices = (uint32_t*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+ to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkPresentInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentInfoKHR* from,
VkPresentInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphores = nullptr;
if (from->pWaitSemaphores)
{
- to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+ to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
}
to->pSwapchains = nullptr;
if (from->pSwapchains)
{
- to->pSwapchains = (VkSwapchainKHR*)pool->dupArray(from->pSwapchains, from->swapchainCount * sizeof(const VkSwapchainKHR));
+ to->pSwapchains = (VkSwapchainKHR*)alloc->dupArray(from->pSwapchains, from->swapchainCount * sizeof(const VkSwapchainKHR));
}
to->pImageIndices = nullptr;
if (from->pImageIndices)
{
- to->pImageIndices = (uint32_t*)pool->dupArray(from->pImageIndices, from->swapchainCount * sizeof(const uint32_t));
+ to->pImageIndices = (uint32_t*)alloc->dupArray(from->pImageIndices, from->swapchainCount * sizeof(const uint32_t));
}
to->pResults = nullptr;
if (from->pResults)
{
- to->pResults = (VkResult*)pool->dupArray(from->pResults, from->swapchainCount * sizeof(VkResult));
+ to->pResults = (VkResult*)alloc->dupArray(from->pResults, from->swapchainCount * sizeof(VkResult));
}
}
void deepcopy_VkImageSwapchainCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSwapchainCreateInfoKHR* from,
VkImageSwapchainCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBindImageMemorySwapchainInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindImageMemorySwapchainInfoKHR* from,
VkBindImageMemorySwapchainInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAcquireNextImageInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAcquireNextImageInfoKHR* from,
VkAcquireNextImageInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupPresentCapabilitiesKHR* from,
VkDeviceGroupPresentCapabilitiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupPresentInfoKHR* from,
VkDeviceGroupPresentInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pDeviceMasks, from->swapchainCount * sizeof(const uint32_t));
+ to->pDeviceMasks = (uint32_t*)alloc->dupArray(from->pDeviceMasks, from->swapchainCount * sizeof(const uint32_t));
}
}
void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupSwapchainCreateInfoKHR* from,
VkDeviceGroupSwapchainCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_display
void deepcopy_VkDisplayModeParametersKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayModeParametersKHR* from,
VkDisplayModeParametersKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkExtent2D(pool, &from->visibleRegion, (VkExtent2D*)(&to->visibleRegion));
+ deepcopy_VkExtent2D(alloc, rootType, &from->visibleRegion, (VkExtent2D*)(&to->visibleRegion));
}
void deepcopy_VkDisplayModeCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayModeCreateInfoKHR* from,
VkDisplayModeCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayModeParametersKHR(pool, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
+ deepcopy_VkDisplayModeParametersKHR(alloc, rootType, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
}
void deepcopy_VkDisplayModePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayModePropertiesKHR* from,
VkDisplayModePropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkDisplayModeParametersKHR(pool, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
+ deepcopy_VkDisplayModeParametersKHR(alloc, rootType, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
}
void deepcopy_VkDisplayPlaneCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilitiesKHR* from,
VkDisplayPlaneCapabilitiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkOffset2D(pool, &from->minSrcPosition, (VkOffset2D*)(&to->minSrcPosition));
- deepcopy_VkOffset2D(pool, &from->maxSrcPosition, (VkOffset2D*)(&to->maxSrcPosition));
- deepcopy_VkExtent2D(pool, &from->minSrcExtent, (VkExtent2D*)(&to->minSrcExtent));
- deepcopy_VkExtent2D(pool, &from->maxSrcExtent, (VkExtent2D*)(&to->maxSrcExtent));
- deepcopy_VkOffset2D(pool, &from->minDstPosition, (VkOffset2D*)(&to->minDstPosition));
- deepcopy_VkOffset2D(pool, &from->maxDstPosition, (VkOffset2D*)(&to->maxDstPosition));
- deepcopy_VkExtent2D(pool, &from->minDstExtent, (VkExtent2D*)(&to->minDstExtent));
- deepcopy_VkExtent2D(pool, &from->maxDstExtent, (VkExtent2D*)(&to->maxDstExtent));
+ deepcopy_VkOffset2D(alloc, rootType, &from->minSrcPosition, (VkOffset2D*)(&to->minSrcPosition));
+ deepcopy_VkOffset2D(alloc, rootType, &from->maxSrcPosition, (VkOffset2D*)(&to->maxSrcPosition));
+ deepcopy_VkExtent2D(alloc, rootType, &from->minSrcExtent, (VkExtent2D*)(&to->minSrcExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxSrcExtent, (VkExtent2D*)(&to->maxSrcExtent));
+ deepcopy_VkOffset2D(alloc, rootType, &from->minDstPosition, (VkOffset2D*)(&to->minDstPosition));
+ deepcopy_VkOffset2D(alloc, rootType, &from->maxDstPosition, (VkOffset2D*)(&to->maxDstPosition));
+ deepcopy_VkExtent2D(alloc, rootType, &from->minDstExtent, (VkExtent2D*)(&to->minDstExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxDstExtent, (VkExtent2D*)(&to->maxDstExtent));
}
void deepcopy_VkDisplayPlanePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlanePropertiesKHR* from,
VkDisplayPlanePropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkDisplayPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPropertiesKHR* from,
VkDisplayPropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
to->displayName = nullptr;
if (from->displayName)
{
- to->displayName = pool->strDup(from->displayName);
+ to->displayName = alloc->strDup(from->displayName);
}
- deepcopy_VkExtent2D(pool, &from->physicalDimensions, (VkExtent2D*)(&to->physicalDimensions));
- deepcopy_VkExtent2D(pool, &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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplaySurfaceCreateInfoKHR* from,
VkDisplaySurfaceCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
}
#endif
#ifdef VK_KHR_display_swapchain
void deepcopy_VkDisplayPresentInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPresentInfoKHR* from,
VkDisplayPresentInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkRect2D(pool, &from->srcRect, (VkRect2D*)(&to->srcRect));
- deepcopy_VkRect2D(pool, &from->dstRect, (VkRect2D*)(&to->dstRect));
+ deepcopy_VkRect2D(alloc, rootType, &from->srcRect, (VkRect2D*)(&to->srcRect));
+ deepcopy_VkRect2D(alloc, rootType, &from->dstRect, (VkRect2D*)(&to->dstRect));
}
#endif
#ifdef VK_KHR_xlib_surface
void deepcopy_VkXlibSurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkXlibSurfaceCreateInfoKHR* from,
VkXlibSurfaceCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->dpy = nullptr;
if (from->dpy)
{
- to->dpy = (Display*)pool->dupArray(from->dpy, sizeof(Display));
+ to->dpy = (Display*)alloc->dupArray(from->dpy, sizeof(Display));
}
}
#endif
#ifdef VK_KHR_xcb_surface
void deepcopy_VkXcbSurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkXcbSurfaceCreateInfoKHR* from,
VkXcbSurfaceCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->connection, sizeof(xcb_connection_t));
+ to->connection = (xcb_connection_t*)alloc->dupArray(from->connection, sizeof(xcb_connection_t));
}
}
#endif
#ifdef VK_KHR_wayland_surface
void deepcopy_VkWaylandSurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWaylandSurfaceCreateInfoKHR* from,
VkWaylandSurfaceCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->display = nullptr;
if (from->display)
{
- to->display = (wl_display*)pool->dupArray(from->display, sizeof(wl_display));
+ to->display = (wl_display*)alloc->dupArray(from->display, sizeof(wl_display));
}
to->surface = nullptr;
if (from->surface)
{
- to->surface = (wl_surface*)pool->dupArray(from->surface, sizeof(wl_surface));
+ to->surface = (wl_surface*)alloc->dupArray(from->surface, sizeof(wl_surface));
}
}
#endif
#ifdef VK_KHR_android_surface
void deepcopy_VkAndroidSurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAndroidSurfaceCreateInfoKHR* from,
VkAndroidSurfaceCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->window = nullptr;
if (from->window)
{
- to->window = (ANativeWindow*)pool->dupArray(from->window, sizeof(ANativeWindow));
+ to->window = (ANativeWindow*)alloc->dupArray(from->window, sizeof(ANativeWindow));
}
}
#endif
#ifdef VK_KHR_win32_surface
void deepcopy_VkWin32SurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWin32SurfaceCreateInfoKHR* from,
VkWin32SurfaceCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -5673,212 +6896,260 @@
#endif
#ifdef VK_KHR_external_memory_win32
void deepcopy_VkImportMemoryWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoKHR* from,
VkImportMemoryWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExportMemoryWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoKHR* from,
VkExportMemoryWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
}
}
void deepcopy_VkMemoryWin32HandlePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryWin32HandlePropertiesKHR* from,
VkMemoryWin32HandlePropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryGetWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryGetWin32HandleInfoKHR* from,
VkMemoryGetWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_external_memory_fd
void deepcopy_VkImportMemoryFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportMemoryFdInfoKHR* from,
VkImportMemoryFdInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryFdPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryFdPropertiesKHR* from,
VkMemoryFdPropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryGetFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryGetFdInfoKHR* from,
VkMemoryGetFdInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
VkWin32KeyedMutexAcquireReleaseInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAcquireSyncs = nullptr;
if (from->pAcquireSyncs)
{
- to->pAcquireSyncs = (VkDeviceMemory*)pool->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
+ to->pAcquireSyncs = (VkDeviceMemory*)alloc->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
}
to->pAcquireKeys = nullptr;
if (from->pAcquireKeys)
{
- to->pAcquireKeys = (uint64_t*)pool->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
+ to->pAcquireKeys = (uint64_t*)alloc->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
}
to->pAcquireTimeouts = nullptr;
if (from->pAcquireTimeouts)
{
- to->pAcquireTimeouts = (uint32_t*)pool->dupArray(from->pAcquireTimeouts, from->acquireCount * sizeof(const uint32_t));
+ to->pAcquireTimeouts = (uint32_t*)alloc->dupArray(from->pAcquireTimeouts, from->acquireCount * sizeof(const uint32_t));
}
to->pReleaseSyncs = nullptr;
if (from->pReleaseSyncs)
{
- to->pReleaseSyncs = (VkDeviceMemory*)pool->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
+ to->pReleaseSyncs = (VkDeviceMemory*)alloc->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
}
to->pReleaseKeys = nullptr;
if (from->pReleaseKeys)
{
- to->pReleaseKeys = (uint64_t*)pool->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
+ to->pReleaseKeys = (uint64_t*)alloc->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
}
}
@@ -5889,175 +7160,217 @@
#endif
#ifdef VK_KHR_external_semaphore_win32
void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportSemaphoreWin32HandleInfoKHR* from,
VkImportSemaphoreWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportSemaphoreWin32HandleInfoKHR* from,
VkExportSemaphoreWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
}
}
void deepcopy_VkD3D12FenceSubmitInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkD3D12FenceSubmitInfoKHR* from,
VkD3D12FenceSubmitInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValuesCount * sizeof(const uint64_t));
+ to->pWaitSemaphoreValues = (uint64_t*)alloc->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValuesCount * sizeof(const uint64_t));
}
to->pSignalSemaphoreValues = nullptr;
if (from->pSignalSemaphoreValues)
{
- to->pSignalSemaphoreValues = (uint64_t*)pool->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ to->pSignalSemaphoreValues = (uint64_t*)alloc->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValuesCount * sizeof(const uint64_t));
}
}
void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreGetWin32HandleInfoKHR* from,
VkSemaphoreGetWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_external_semaphore_fd
void deepcopy_VkImportSemaphoreFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportSemaphoreFdInfoKHR* from,
VkImportSemaphoreFdInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSemaphoreGetFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreGetFdInfoKHR* from,
VkSemaphoreGetFdInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_push_descriptor
void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
VkPhysicalDevicePushDescriptorPropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -6068,68 +7381,78 @@
#endif
#ifdef VK_KHR_incremental_present
void deepcopy_VkRectLayerKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRectLayerKHR* from,
VkRectLayerKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkOffset2D(pool, &from->offset, (VkOffset2D*)(&to->offset));
- deepcopy_VkExtent2D(pool, &from->extent, (VkExtent2D*)(&to->extent));
+ deepcopy_VkOffset2D(alloc, rootType, &from->offset, (VkOffset2D*)(&to->offset));
+ deepcopy_VkExtent2D(alloc, rootType, &from->extent, (VkExtent2D*)(&to->extent));
}
void deepcopy_VkPresentRegionKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentRegionKHR* from,
VkPresentRegionKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
if (from)
{
to->pRectangles = nullptr;
if (from->pRectangles)
{
- to->pRectangles = (VkRectLayerKHR*)pool->alloc(from->rectangleCount * sizeof(const VkRectLayerKHR));
+ 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(pool, from->pRectangles + i, (VkRectLayerKHR*)(to->pRectangles + i));
+ deepcopy_VkRectLayerKHR(alloc, rootType, from->pRectangles + i, (VkRectLayerKHR*)(to->pRectangles + i));
}
}
}
}
void deepcopy_VkPresentRegionsKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentRegionsKHR* from,
VkPresentRegionsKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pRegions = nullptr;
if (from->pRegions)
{
- to->pRegions = (VkPresentRegionKHR*)pool->alloc(from->swapchainCount * sizeof(const VkPresentRegionKHR));
+ 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(pool, from->pRegions + i, (VkPresentRegionKHR*)(to->pRegions + i));
+ deepcopy_VkPresentRegionKHR(alloc, rootType, from->pRegions + i, (VkPresentRegionKHR*)(to->pRegions + i));
}
}
}
@@ -6144,24 +7467,30 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* from,
VkSharedPresentSurfaceCapabilitiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -6172,210 +7501,264 @@
#endif
#ifdef VK_KHR_external_fence_win32
void deepcopy_VkImportFenceWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportFenceWin32HandleInfoKHR* from,
VkImportFenceWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExportFenceWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportFenceWin32HandleInfoKHR* from,
VkExportFenceWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
}
}
void deepcopy_VkFenceGetWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFenceGetWin32HandleInfoKHR* from,
VkFenceGetWin32HandleInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_external_fence_fd
void deepcopy_VkImportFenceFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportFenceFdInfoKHR* from,
VkImportFenceFdInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkFenceGetFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFenceGetFdInfoKHR* from,
VkFenceGetFdInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_performance_query
void deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* from,
VkPhysicalDevicePerformanceQueryFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* from,
VkPhysicalDevicePerformanceQueryPropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPerformanceCounterKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceCounterKHR* from,
VkPerformanceCounterKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceCounterDescriptionKHR* from,
VkPerformanceCounterDescriptionKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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->category, from->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
@@ -6383,82 +7766,102 @@
}
void deepcopy_VkQueryPoolPerformanceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueryPoolPerformanceCreateInfoKHR* from,
VkQueryPoolPerformanceCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pCounterIndices, from->counterIndexCount * sizeof(const uint32_t));
+ to->pCounterIndices = (uint32_t*)alloc->dupArray(from->pCounterIndices, from->counterIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkPerformanceCounterResultKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceCounterResultKHR* from,
VkPerformanceCounterResultKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkAcquireProfilingLockInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAcquireProfilingLockInfoKHR* from,
VkAcquireProfilingLockInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPerformanceQuerySubmitInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceQuerySubmitInfoKHR* from,
VkPerformanceQuerySubmitInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -6467,71 +7870,89 @@
#endif
#ifdef VK_KHR_get_surface_capabilities2
void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSurfaceInfo2KHR* from,
VkPhysicalDeviceSurfaceInfo2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSurfaceCapabilities2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceCapabilities2KHR* from,
VkSurfaceCapabilities2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSurfaceCapabilitiesKHR(pool, &from->surfaceCapabilities, (VkSurfaceCapabilitiesKHR*)(&to->surfaceCapabilities));
+ deepcopy_VkSurfaceCapabilitiesKHR(alloc, rootType, &from->surfaceCapabilities, (VkSurfaceCapabilitiesKHR*)(&to->surfaceCapabilities));
}
void deepcopy_VkSurfaceFormat2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceFormat2KHR* from,
VkSurfaceFormat2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSurfaceFormatKHR(pool, &from->surfaceFormat, (VkSurfaceFormatKHR*)(&to->surfaceFormat));
+ deepcopy_VkSurfaceFormatKHR(alloc, rootType, &from->surfaceFormat, (VkSurfaceFormatKHR*)(&to->surfaceFormat));
}
#endif
@@ -6539,117 +7960,147 @@
#endif
#ifdef VK_KHR_get_display_properties2
void deepcopy_VkDisplayProperties2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayProperties2KHR* from,
VkDisplayProperties2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayPropertiesKHR(pool, &from->displayProperties, (VkDisplayPropertiesKHR*)(&to->displayProperties));
+ deepcopy_VkDisplayPropertiesKHR(alloc, rootType, &from->displayProperties, (VkDisplayPropertiesKHR*)(&to->displayProperties));
}
void deepcopy_VkDisplayPlaneProperties2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlaneProperties2KHR* from,
VkDisplayPlaneProperties2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayPlanePropertiesKHR(pool, &from->displayPlaneProperties, (VkDisplayPlanePropertiesKHR*)(&to->displayPlaneProperties));
+ deepcopy_VkDisplayPlanePropertiesKHR(alloc, rootType, &from->displayPlaneProperties, (VkDisplayPlanePropertiesKHR*)(&to->displayPlaneProperties));
}
void deepcopy_VkDisplayModeProperties2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayModeProperties2KHR* from,
VkDisplayModeProperties2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayModePropertiesKHR(pool, &from->displayModeProperties, (VkDisplayModePropertiesKHR*)(&to->displayModeProperties));
+ deepcopy_VkDisplayModePropertiesKHR(alloc, rootType, &from->displayModeProperties, (VkDisplayModePropertiesKHR*)(&to->displayModeProperties));
}
void deepcopy_VkDisplayPlaneInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlaneInfo2KHR* from,
VkDisplayPlaneInfo2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDisplayPlaneCapabilities2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilities2KHR* from,
VkDisplayPlaneCapabilities2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayPlaneCapabilitiesKHR(pool, &from->capabilities, (VkDisplayPlaneCapabilitiesKHR*)(&to->capabilities));
+ deepcopy_VkDisplayPlaneCapabilitiesKHR(alloc, rootType, &from->capabilities, (VkDisplayPlaneCapabilitiesKHR*)(&to->capabilities));
}
#endif
@@ -6669,46 +8120,58 @@
#endif
#ifdef VK_KHR_portability_subset
void deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* from,
VkPhysicalDevicePortabilitySubsetFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* from,
VkPhysicalDevicePortabilitySubsetPropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -6725,24 +8188,30 @@
#endif
#ifdef VK_KHR_shader_clock
void deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* from,
VkPhysicalDeviceShaderClockFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -6761,150 +8230,186 @@
#endif
#ifdef VK_KHR_shader_terminate_invocation
void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* from,
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_fragment_shading_rate
void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFragmentShadingRateAttachmentInfoKHR* from,
VkFragmentShadingRateAttachmentInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pFragmentShadingRateAttachment = nullptr;
if (from->pFragmentShadingRateAttachment)
{
- to->pFragmentShadingRateAttachment = (VkAttachmentReference2*)pool->alloc(sizeof(const VkAttachmentReference2));
- deepcopy_VkAttachmentReference2(pool, from->pFragmentShadingRateAttachment, (VkAttachmentReference2*)(to->pFragmentShadingRateAttachment));
+ to->pFragmentShadingRateAttachment = (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
+ deepcopy_VkAttachmentReference2(alloc, rootType, from->pFragmentShadingRateAttachment, (VkAttachmentReference2*)(to->pFragmentShadingRateAttachment));
}
- deepcopy_VkExtent2D(pool, &from->shadingRateAttachmentTexelSize, (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateAttachmentTexelSize, (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
}
void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* from,
VkPipelineFragmentShadingRateStateCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
memcpy(to->combinerOps, from->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}
void deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* from,
VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* from,
VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->minFragmentShadingRateAttachmentTexelSize, (VkExtent2D*)(&to->minFragmentShadingRateAttachmentTexelSize));
- deepcopy_VkExtent2D(pool, &from->maxFragmentShadingRateAttachmentTexelSize, (VkExtent2D*)(&to->maxFragmentShadingRateAttachmentTexelSize));
- deepcopy_VkExtent2D(pool, &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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* from,
VkPhysicalDeviceFragmentShadingRateKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
}
#endif
@@ -6912,24 +8417,30 @@
#endif
#ifdef VK_KHR_surface_protected_capabilities
void deepcopy_VkSurfaceProtectedCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceProtectedCapabilitiesKHR* from,
VkSurfaceProtectedCapabilitiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -6944,184 +8455,228 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* from,
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineInfoKHR* from,
VkPipelineInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineExecutablePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutablePropertiesKHR* from,
VkPipelineExecutablePropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ 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));
}
void deepcopy_VkPipelineExecutableInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutableInfoKHR* from,
VkPipelineExecutableInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineExecutableStatisticValueKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticValueKHR* from,
VkPipelineExecutableStatisticValueKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineExecutableStatisticKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticKHR* from,
VkPipelineExecutableStatisticKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ 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(pool, &from->value, (VkPipelineExecutableStatisticValueKHR*)(&to->value));
+ deepcopy_VkPipelineExecutableStatisticValueKHR(alloc, rootType, &from->value, (VkPipelineExecutableStatisticValueKHR*)(&to->value));
}
void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* from,
VkPipelineExecutableInternalRepresentationKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ 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)
{
- to->pData = (void*)pool->dupArray(from->pData, from->dataSize * sizeof(uint8_t));
+ to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(uint8_t));
}
}
#endif
#ifdef VK_KHR_pipeline_library
void deepcopy_VkPipelineLibraryCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineLibraryCreateInfoKHR* from,
VkPipelineLibraryCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pLibraries = nullptr;
if (from->pLibraries)
{
- to->pLibraries = (VkPipeline*)pool->dupArray(from->pLibraries, from->libraryCount * sizeof(const VkPipeline));
+ to->pLibraries = (VkPipeline*)alloc->dupArray(from->pLibraries, from->libraryCount * sizeof(const VkPipeline));
}
}
@@ -7130,343 +8685,409 @@
#endif
#ifdef VK_KHR_copy_commands2
void deepcopy_VkBufferCopy2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferCopy2KHR* from,
VkBufferCopy2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCopyBufferInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyBufferInfo2KHR* from,
VkCopyBufferInfo2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pRegions = nullptr;
if (from->pRegions)
{
- to->pRegions = (VkBufferCopy2KHR*)pool->alloc(from->regionCount * sizeof(const VkBufferCopy2KHR));
+ 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(pool, from->pRegions + i, (VkBufferCopy2KHR*)(to->pRegions + i));
+ deepcopy_VkBufferCopy2KHR(alloc, rootType, from->pRegions + i, (VkBufferCopy2KHR*)(to->pRegions + i));
}
}
}
}
void deepcopy_VkImageCopy2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageCopy2KHR* from,
VkImageCopy2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
- deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
- deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
- deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
- deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+ 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_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
+ deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
void deepcopy_VkCopyImageInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyImageInfo2KHR* from,
VkCopyImageInfo2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pRegions = nullptr;
if (from->pRegions)
{
- to->pRegions = (VkImageCopy2KHR*)pool->alloc(from->regionCount * sizeof(const VkImageCopy2KHR));
+ 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(pool, from->pRegions + i, (VkImageCopy2KHR*)(to->pRegions + i));
+ deepcopy_VkImageCopy2KHR(alloc, rootType, from->pRegions + i, (VkImageCopy2KHR*)(to->pRegions + i));
}
}
}
}
void deepcopy_VkBufferImageCopy2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferImageCopy2KHR* from,
VkBufferImageCopy2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceLayers(pool, &from->imageSubresource, (VkImageSubresourceLayers*)(&to->imageSubresource));
- deepcopy_VkOffset3D(pool, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
- deepcopy_VkExtent3D(pool, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+ 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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyBufferToImageInfo2KHR* from,
VkCopyBufferToImageInfo2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pRegions = nullptr;
if (from->pRegions)
{
- to->pRegions = (VkBufferImageCopy2KHR*)pool->alloc(from->regionCount * sizeof(const VkBufferImageCopy2KHR));
+ 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(pool, from->pRegions + i, (VkBufferImageCopy2KHR*)(to->pRegions + i));
+ deepcopy_VkBufferImageCopy2KHR(alloc, rootType, from->pRegions + i, (VkBufferImageCopy2KHR*)(to->pRegions + i));
}
}
}
}
void deepcopy_VkCopyImageToBufferInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyImageToBufferInfo2KHR* from,
VkCopyImageToBufferInfo2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pRegions = nullptr;
if (from->pRegions)
{
- to->pRegions = (VkBufferImageCopy2KHR*)pool->alloc(from->regionCount * sizeof(const VkBufferImageCopy2KHR));
+ 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(pool, from->pRegions + i, (VkBufferImageCopy2KHR*)(to->pRegions + i));
+ deepcopy_VkBufferImageCopy2KHR(alloc, rootType, from->pRegions + i, (VkBufferImageCopy2KHR*)(to->pRegions + i));
}
}
}
}
void deepcopy_VkImageBlit2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageBlit2KHR* from,
VkImageBlit2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- deepcopy_VkOffset3D(pool, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
+ deepcopy_VkOffset3D(alloc, rootType, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
}
- deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- deepcopy_VkOffset3D(pool, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
+ deepcopy_VkOffset3D(alloc, rootType, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
}
}
void deepcopy_VkBlitImageInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBlitImageInfo2KHR* from,
VkBlitImageInfo2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pRegions = nullptr;
if (from->pRegions)
{
- to->pRegions = (VkImageBlit2KHR*)pool->alloc(from->regionCount * sizeof(const VkImageBlit2KHR));
+ 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(pool, from->pRegions + i, (VkImageBlit2KHR*)(to->pRegions + i));
+ deepcopy_VkImageBlit2KHR(alloc, rootType, from->pRegions + i, (VkImageBlit2KHR*)(to->pRegions + i));
}
}
}
}
void deepcopy_VkImageResolve2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageResolve2KHR* from,
VkImageResolve2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceLayers(pool, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
- deepcopy_VkOffset3D(pool, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
- deepcopy_VkImageSubresourceLayers(pool, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
- deepcopy_VkOffset3D(pool, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
- deepcopy_VkExtent3D(pool, &from->extent, (VkExtent3D*)(&to->extent));
+ 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_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
+ deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
void deepcopy_VkResolveImageInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkResolveImageInfo2KHR* from,
VkResolveImageInfo2KHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pRegions = nullptr;
if (from->pRegions)
{
- to->pRegions = (VkImageResolve2KHR*)pool->alloc(from->regionCount * sizeof(const VkImageResolve2KHR));
+ 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(pool, from->pRegions + i, (VkImageResolve2KHR*)(to->pRegions + i));
+ deepcopy_VkImageResolve2KHR(alloc, rootType, from->pRegions + i, (VkImageResolve2KHR*)(to->pRegions + i));
}
}
}
@@ -7475,58 +9096,70 @@
#endif
#ifdef VK_ANDROID_native_buffer
void deepcopy_VkNativeBufferANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkNativeBufferANDROID* from,
VkNativeBufferANDROID* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->handle = nullptr;
if (from->handle)
{
- to->handle = (uint32_t*)pool->dupArray(from->handle, sizeof(const uint32_t));
+ to->handle = (uint32_t*)alloc->dupArray(from->handle, sizeof(const uint32_t));
}
}
#endif
#ifdef VK_EXT_debug_report
void deepcopy_VkDebugReportCallbackCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugReportCallbackCreateInfoEXT* from,
VkDebugReportCallbackCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pUserData = nullptr;
if (from->pUserData)
{
- to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+ to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
@@ -7539,24 +9172,30 @@
#endif
#ifdef VK_AMD_rasterization_order
void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* from,
VkPipelineRasterizationStateRasterizationOrderAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -7567,83 +9206,101 @@
#endif
#ifdef VK_EXT_debug_marker
void deepcopy_VkDebugMarkerObjectNameInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugMarkerObjectNameInfoEXT* from,
VkDebugMarkerObjectNameInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pObjectName = nullptr;
if (from->pObjectName)
{
- to->pObjectName = pool->strDup(from->pObjectName);
+ to->pObjectName = alloc->strDup(from->pObjectName);
}
}
void deepcopy_VkDebugMarkerObjectTagInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugMarkerObjectTagInfoEXT* from,
VkDebugMarkerObjectTagInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pTag = nullptr;
if (from->pTag)
{
- to->pTag = (void*)pool->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
+ to->pTag = (void*)alloc->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
}
}
void deepcopy_VkDebugMarkerMarkerInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugMarkerMarkerInfoEXT* from,
VkDebugMarkerMarkerInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pMarkerName = nullptr;
if (from->pMarkerName)
{
- to->pMarkerName = pool->strDup(from->pMarkerName);
+ to->pMarkerName = alloc->strDup(from->pMarkerName);
}
memcpy(to->color, from->color, 4 * sizeof(float));
}
@@ -7653,182 +9310,230 @@
#endif
#ifdef VK_NV_dedicated_allocation
void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDedicatedAllocationImageCreateInfoNV* from,
VkDedicatedAllocationImageCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDedicatedAllocationBufferCreateInfoNV* from,
VkDedicatedAllocationBufferCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* from,
VkDedicatedAllocationMemoryAllocateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_transform_feedback
void deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* from,
VkPhysicalDeviceTransformFeedbackFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* from,
VkPhysicalDeviceTransformFeedbackPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* from,
VkPipelineRasterizationStateStreamCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NVX_image_view_handle
void deepcopy_VkImageViewHandleInfoNVX(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewHandleInfoNVX* from,
VkImageViewHandleInfoNVX* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkImageViewAddressPropertiesNVX(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewAddressPropertiesNVX* from,
VkImageViewAddressPropertiesNVX* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -7843,46 +9548,56 @@
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* from,
VkTextureLODGatherFormatPropertiesAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_AMD_shader_info
void deepcopy_VkShaderResourceUsageAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShaderResourceUsageAMD* from,
VkShaderResourceUsageAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkShaderStatisticsInfoAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShaderStatisticsInfoAMD* from,
VkShaderStatisticsInfoAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkShaderResourceUsageAMD(pool, &from->resourceUsage, (VkShaderResourceUsageAMD*)(&to->resourceUsage));
+ deepcopy_VkShaderResourceUsageAMD(alloc, rootType, &from->resourceUsage, (VkShaderResourceUsageAMD*)(&to->resourceUsage));
memcpy(to->computeWorkGroupSize, from->computeWorkGroupSize, 3 * sizeof(uint32_t));
}
@@ -7891,48 +9606,60 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* from,
VkStreamDescriptorSurfaceCreateInfoGGP* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_corner_sampled_image
void deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* from,
VkPhysicalDeviceCornerSampledImageFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -7941,216 +9668,260 @@
#endif
#ifdef VK_NV_external_memory_capabilities
void deepcopy_VkExternalImageFormatPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalImageFormatPropertiesNV* from,
VkExternalImageFormatPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkImageFormatProperties(pool, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
+ deepcopy_VkImageFormatProperties(alloc, rootType, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
}
#endif
#ifdef VK_NV_external_memory
void deepcopy_VkExternalMemoryImageCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfoNV* from,
VkExternalMemoryImageCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExportMemoryAllocateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfoNV* from,
VkExportMemoryAllocateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_external_memory_win32
void deepcopy_VkImportMemoryWin32HandleInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoNV* from,
VkImportMemoryWin32HandleInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExportMemoryWin32HandleInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoNV* from,
VkExportMemoryWin32HandleInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
}
}
#endif
#ifdef VK_NV_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
VkWin32KeyedMutexAcquireReleaseInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAcquireSyncs = nullptr;
if (from->pAcquireSyncs)
{
- to->pAcquireSyncs = (VkDeviceMemory*)pool->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
+ to->pAcquireSyncs = (VkDeviceMemory*)alloc->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
}
to->pAcquireKeys = nullptr;
if (from->pAcquireKeys)
{
- to->pAcquireKeys = (uint64_t*)pool->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
+ to->pAcquireKeys = (uint64_t*)alloc->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
}
to->pAcquireTimeoutMilliseconds = nullptr;
if (from->pAcquireTimeoutMilliseconds)
{
- to->pAcquireTimeoutMilliseconds = (uint32_t*)pool->dupArray(from->pAcquireTimeoutMilliseconds, from->acquireCount * sizeof(const uint32_t));
+ to->pAcquireTimeoutMilliseconds = (uint32_t*)alloc->dupArray(from->pAcquireTimeoutMilliseconds, from->acquireCount * sizeof(const uint32_t));
}
to->pReleaseSyncs = nullptr;
if (from->pReleaseSyncs)
{
- to->pReleaseSyncs = (VkDeviceMemory*)pool->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
+ to->pReleaseSyncs = (VkDeviceMemory*)alloc->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
}
to->pReleaseKeys = nullptr;
if (from->pReleaseKeys)
{
- to->pReleaseKeys = (uint64_t*)pool->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
+ to->pReleaseKeys = (uint64_t*)alloc->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
}
}
#endif
#ifdef VK_EXT_validation_flags
void deepcopy_VkValidationFlagsEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkValidationFlagsEXT* from,
VkValidationFlagsEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDisabledValidationChecks = nullptr;
if (from->pDisabledValidationChecks)
{
- to->pDisabledValidationChecks = (VkValidationCheckEXT*)pool->dupArray(from->pDisabledValidationChecks, from->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+ to->pDisabledValidationChecks = (VkValidationCheckEXT*)alloc->dupArray(from->pDisabledValidationChecks, from->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
}
}
#endif
#ifdef VK_NN_vi_surface
void deepcopy_VkViSurfaceCreateInfoNN(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkViSurfaceCreateInfoNN* from,
VkViSurfaceCreateInfoNN* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->window = nullptr;
if (from->window)
{
- to->window = (void*)pool->dupArray(from->window, sizeof(uint8_t));
+ to->window = (void*)alloc->dupArray(from->window, sizeof(uint8_t));
}
}
@@ -8161,182 +9932,226 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* from,
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_astc_decode_mode
void deepcopy_VkImageViewASTCDecodeModeEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewASTCDecodeModeEXT* from,
VkImageViewASTCDecodeModeEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
VkPhysicalDeviceASTCDecodeFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_conditional_rendering
void deepcopy_VkConditionalRenderingBeginInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkConditionalRenderingBeginInfoEXT* from,
VkConditionalRenderingBeginInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
VkPhysicalDeviceConditionalRenderingFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
VkCommandBufferInheritanceConditionalRenderingInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_clip_space_w_scaling
void deepcopy_VkViewportWScalingNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkViewportWScalingNV* from,
VkViewportWScalingNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportWScalingStateCreateInfoNV* from,
VkPipelineViewportWScalingStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pViewportWScalings = nullptr;
if (from->pViewportWScalings)
{
- to->pViewportWScalings = (VkViewportWScalingNV*)pool->alloc(from->viewportCount * sizeof(const VkViewportWScalingNV));
+ 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(pool, from->pViewportWScalings + i, (VkViewportWScalingNV*)(to->pViewportWScalings + i));
+ deepcopy_VkViewportWScalingNV(alloc, rootType, from->pViewportWScalings + i, (VkViewportWScalingNV*)(to->pViewportWScalings + i));
}
}
}
@@ -8349,179 +10164,221 @@
#endif
#ifdef VK_EXT_display_surface_counter
void deepcopy_VkSurfaceCapabilities2EXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceCapabilities2EXT* from,
VkSurfaceCapabilities2EXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->currentExtent, (VkExtent2D*)(&to->currentExtent));
- deepcopy_VkExtent2D(pool, &from->minImageExtent, (VkExtent2D*)(&to->minImageExtent));
- deepcopy_VkExtent2D(pool, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->currentExtent, (VkExtent2D*)(&to->currentExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->minImageExtent, (VkExtent2D*)(&to->minImageExtent));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
}
#endif
#ifdef VK_EXT_display_control
void deepcopy_VkDisplayPowerInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPowerInfoEXT* from,
VkDisplayPowerInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceEventInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceEventInfoEXT* from,
VkDeviceEventInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDisplayEventInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayEventInfoEXT* from,
VkDisplayEventInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSwapchainCounterCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSwapchainCounterCreateInfoEXT* from,
VkSwapchainCounterCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_GOOGLE_display_timing
void deepcopy_VkRefreshCycleDurationGOOGLE(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRefreshCycleDurationGOOGLE* from,
VkRefreshCycleDurationGOOGLE* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPastPresentationTimingGOOGLE(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPastPresentationTimingGOOGLE* from,
VkPastPresentationTimingGOOGLE* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPresentTimeGOOGLE(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentTimeGOOGLE* from,
VkPresentTimeGOOGLE* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPresentTimesInfoGOOGLE(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentTimesInfoGOOGLE* from,
VkPresentTimesInfoGOOGLE* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pTimes = nullptr;
if (from->pTimes)
{
- to->pTimes = (VkPresentTimeGOOGLE*)pool->alloc(from->swapchainCount * sizeof(const VkPresentTimeGOOGLE));
+ 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(pool, from->pTimes + i, (VkPresentTimeGOOGLE*)(to->pTimes + i));
+ deepcopy_VkPresentTimeGOOGLE(alloc, rootType, from->pTimes + i, (VkPresentTimeGOOGLE*)(to->pTimes + i));
}
}
}
@@ -8536,68 +10393,82 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_viewport_swizzle
void deepcopy_VkViewportSwizzleNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkViewportSwizzleNV* from,
VkViewportSwizzleNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* from,
VkPipelineViewportSwizzleStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pViewportSwizzles = nullptr;
if (from->pViewportSwizzles)
{
- to->pViewportSwizzles = (VkViewportSwizzleNV*)pool->alloc(from->viewportCount * sizeof(const VkViewportSwizzleNV));
+ 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(pool, from->pViewportSwizzles + i, (VkViewportSwizzleNV*)(to->pViewportSwizzles + i));
+ deepcopy_VkViewportSwizzleNV(alloc, rootType, from->pViewportSwizzles + i, (VkViewportSwizzleNV*)(to->pViewportSwizzles + i));
}
}
}
@@ -8606,57 +10477,69 @@
#endif
#ifdef VK_EXT_discard_rectangles
void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
VkPhysicalDeviceDiscardRectanglePropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
VkPipelineDiscardRectangleStateCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pDiscardRectangles = nullptr;
if (from->pDiscardRectangles)
{
- to->pDiscardRectangles = (VkRect2D*)pool->alloc(from->discardRectangleCount * sizeof(const VkRect2D));
+ 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(pool, from->pDiscardRectangles + i, (VkRect2D*)(to->pDiscardRectangles + i));
+ deepcopy_VkRect2D(alloc, rootType, from->pDiscardRectangles + i, (VkRect2D*)(to->pDiscardRectangles + i));
}
}
}
@@ -8665,92 +10548,116 @@
#endif
#ifdef VK_EXT_conservative_rasterization
void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
VkPipelineRasterizationConservativeStateCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_depth_clip_enable
void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
VkPhysicalDeviceDepthClipEnableFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
VkPipelineRasterizationDepthClipStateCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -8759,95 +10666,115 @@
#endif
#ifdef VK_EXT_hdr_metadata
void deepcopy_VkXYColorEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkXYColorEXT* from,
VkXYColorEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkHdrMetadataEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkHdrMetadataEXT* from,
VkHdrMetadataEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkXYColorEXT(pool, &from->displayPrimaryRed, (VkXYColorEXT*)(&to->displayPrimaryRed));
- deepcopy_VkXYColorEXT(pool, &from->displayPrimaryGreen, (VkXYColorEXT*)(&to->displayPrimaryGreen));
- deepcopy_VkXYColorEXT(pool, &from->displayPrimaryBlue, (VkXYColorEXT*)(&to->displayPrimaryBlue));
- deepcopy_VkXYColorEXT(pool, &from->whitePoint, (VkXYColorEXT*)(&to->whitePoint));
+ 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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkIOSSurfaceCreateInfoMVK* from,
VkIOSSurfaceCreateInfoMVK* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pView = nullptr;
if (from->pView)
{
- to->pView = (void*)pool->dupArray(from->pView, sizeof(const uint8_t));
+ to->pView = (void*)alloc->dupArray(from->pView, sizeof(const uint8_t));
}
}
#endif
#ifdef VK_MVK_macos_surface
void deepcopy_VkMacOSSurfaceCreateInfoMVK(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMacOSSurfaceCreateInfoMVK* from,
VkMacOSSurfaceCreateInfoMVK* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pView = nullptr;
if (from->pView)
{
- to->pView = (void*)pool->dupArray(from->pView, sizeof(const uint8_t));
+ to->pView = (void*)alloc->dupArray(from->pView, sizeof(const uint8_t));
}
}
@@ -8860,100 +10787,118 @@
#endif
#ifdef VK_EXT_debug_utils
void deepcopy_VkDebugUtilsLabelEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsLabelEXT* from,
VkDebugUtilsLabelEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pLabelName = nullptr;
if (from->pLabelName)
{
- to->pLabelName = pool->strDup(from->pLabelName);
+ to->pLabelName = alloc->strDup(from->pLabelName);
}
memcpy(to->color, from->color, 4 * sizeof(float));
}
void deepcopy_VkDebugUtilsObjectNameInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsObjectNameInfoEXT* from,
VkDebugUtilsObjectNameInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pObjectName = nullptr;
if (from->pObjectName)
{
- to->pObjectName = pool->strDup(from->pObjectName);
+ to->pObjectName = alloc->strDup(from->pObjectName);
}
}
void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCallbackDataEXT* from,
VkDebugUtilsMessengerCallbackDataEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pMessageIdName = nullptr;
if (from->pMessageIdName)
{
- to->pMessageIdName = pool->strDup(from->pMessageIdName);
+ to->pMessageIdName = alloc->strDup(from->pMessageIdName);
}
to->pMessage = nullptr;
if (from->pMessage)
{
- to->pMessage = pool->strDup(from->pMessage);
+ to->pMessage = alloc->strDup(from->pMessage);
}
if (from)
{
to->pQueueLabels = nullptr;
if (from->pQueueLabels)
{
- to->pQueueLabels = (VkDebugUtilsLabelEXT*)pool->alloc(from->queueLabelCount * sizeof(VkDebugUtilsLabelEXT));
+ 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(pool, from->pQueueLabels + i, (VkDebugUtilsLabelEXT*)(to->pQueueLabels + i));
+ deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pQueueLabels + i, (VkDebugUtilsLabelEXT*)(to->pQueueLabels + i));
}
}
}
@@ -8962,11 +10907,11 @@
to->pCmdBufLabels = nullptr;
if (from->pCmdBufLabels)
{
- to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)pool->alloc(from->cmdBufLabelCount * sizeof(VkDebugUtilsLabelEXT));
+ 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(pool, from->pCmdBufLabels + i, (VkDebugUtilsLabelEXT*)(to->pCmdBufLabels + i));
+ deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pCmdBufLabels + i, (VkDebugUtilsLabelEXT*)(to->pCmdBufLabels + i));
}
}
}
@@ -8975,207 +10920,255 @@
to->pObjects = nullptr;
if (from->pObjects)
{
- to->pObjects = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(from->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
+ 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(pool, from->pObjects + i, (VkDebugUtilsObjectNameInfoEXT*)(to->pObjects + i));
+ deepcopy_VkDebugUtilsObjectNameInfoEXT(alloc, rootType, from->pObjects + i, (VkDebugUtilsObjectNameInfoEXT*)(to->pObjects + i));
}
}
}
}
void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCreateInfoEXT* from,
VkDebugUtilsMessengerCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pUserData = nullptr;
if (from->pUserData)
{
- to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+ to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
void deepcopy_VkDebugUtilsObjectTagInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsObjectTagInfoEXT* from,
VkDebugUtilsObjectTagInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pTag = nullptr;
if (from->pTag)
{
- to->pTag = (void*)pool->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
+ 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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAndroidHardwareBufferUsageANDROID* from,
VkAndroidHardwareBufferUsageANDROID* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* from,
VkAndroidHardwareBufferPropertiesANDROID* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
VkAndroidHardwareBufferFormatPropertiesANDROID* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkComponentMapping(pool, &from->samplerYcbcrConversionComponents, (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
+ deepcopy_VkComponentMapping(alloc, rootType, &from->samplerYcbcrConversionComponents, (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
}
void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* from,
VkImportAndroidHardwareBufferInfoANDROID* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->buffer = nullptr;
if (from->buffer)
{
- to->buffer = (AHardwareBuffer*)pool->dupArray(from->buffer, sizeof(AHardwareBuffer));
+ to->buffer = (AHardwareBuffer*)alloc->dupArray(from->buffer, sizeof(AHardwareBuffer));
}
}
void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
VkMemoryGetAndroidHardwareBufferInfoANDROID* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkExternalFormatANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalFormatANDROID* from,
VkExternalFormatANDROID* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -9190,95 +11183,119 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* from,
VkPhysicalDeviceInlineUniformBlockFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* from,
VkPhysicalDeviceInlineUniformBlockPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* from,
VkWriteDescriptorSetInlineUniformBlockEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pData = nullptr;
if (from->pData)
{
- to->pData = (void*)pool->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
+ to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
}
}
void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* from,
VkDescriptorPoolInlineUniformBlockCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -9287,100 +11304,118 @@
#endif
#ifdef VK_EXT_sample_locations
void deepcopy_VkSampleLocationEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSampleLocationEXT* from,
VkSampleLocationEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkSampleLocationsInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSampleLocationsInfoEXT* from,
VkSampleLocationsInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->sampleLocationGridSize, (VkExtent2D*)(&to->sampleLocationGridSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->sampleLocationGridSize, (VkExtent2D*)(&to->sampleLocationGridSize));
if (from)
{
to->pSampleLocations = nullptr;
if (from->pSampleLocations)
{
- to->pSampleLocations = (VkSampleLocationEXT*)pool->alloc(from->sampleLocationsCount * sizeof(const VkSampleLocationEXT));
+ 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(pool, from->pSampleLocations + i, (VkSampleLocationEXT*)(to->pSampleLocations + i));
+ deepcopy_VkSampleLocationEXT(alloc, rootType, from->pSampleLocations + i, (VkSampleLocationEXT*)(to->pSampleLocations + i));
}
}
}
}
void deepcopy_VkAttachmentSampleLocationsEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentSampleLocationsEXT* from,
VkAttachmentSampleLocationsEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+ deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}
void deepcopy_VkSubpassSampleLocationsEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassSampleLocationsEXT* from,
VkSubpassSampleLocationsEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+ deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}
void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassSampleLocationsBeginInfoEXT* from,
VkRenderPassSampleLocationsBeginInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pAttachmentInitialSampleLocations = nullptr;
if (from->pAttachmentInitialSampleLocations)
{
- to->pAttachmentInitialSampleLocations = (VkAttachmentSampleLocationsEXT*)pool->alloc(from->attachmentInitialSampleLocationsCount * sizeof(const VkAttachmentSampleLocationsEXT));
+ 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(pool, from->pAttachmentInitialSampleLocations + i, (VkAttachmentSampleLocationsEXT*)(to->pAttachmentInitialSampleLocations + i));
+ deepcopy_VkAttachmentSampleLocationsEXT(alloc, rootType, from->pAttachmentInitialSampleLocations + i, (VkAttachmentSampleLocationsEXT*)(to->pAttachmentInitialSampleLocations + i));
}
}
}
@@ -9389,204 +11424,252 @@
to->pPostSubpassSampleLocations = nullptr;
if (from->pPostSubpassSampleLocations)
{
- to->pPostSubpassSampleLocations = (VkSubpassSampleLocationsEXT*)pool->alloc(from->postSubpassSampleLocationsCount * sizeof(const VkSubpassSampleLocationsEXT));
+ 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(pool, from->pPostSubpassSampleLocations + i, (VkSubpassSampleLocationsEXT*)(to->pPostSubpassSampleLocations + i));
+ deepcopy_VkSubpassSampleLocationsEXT(alloc, rootType, from->pPostSubpassSampleLocations + i, (VkSubpassSampleLocationsEXT*)(to->pPostSubpassSampleLocations + i));
}
}
}
}
void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* from,
VkPipelineSampleLocationsStateCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+ deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}
void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
VkPhysicalDeviceSampleLocationsPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
memcpy(to->sampleLocationCoordinateRange, from->sampleLocationCoordinateRange, 2 * sizeof(float));
}
void deepcopy_VkMultisamplePropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMultisamplePropertiesEXT* from,
VkMultisamplePropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
VkPipelineColorBlendAdvancedStateCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* from,
VkPipelineCoverageToColorStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* from,
VkPipelineCoverageModulationStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCoverageModulationTable = nullptr;
if (from->pCoverageModulationTable)
{
- to->pCoverageModulationTable = (float*)pool->dupArray(from->pCoverageModulationTable, from->coverageModulationTableCount * sizeof(const float));
+ to->pCoverageModulationTable = (float*)alloc->dupArray(from->pCoverageModulationTable, from->coverageModulationTableCount * sizeof(const float));
}
}
@@ -9595,46 +11678,58 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* from,
VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* from,
VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -9643,208 +11738,252 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
void deepcopy_VkDrmFormatModifierPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesEXT* from,
VkDrmFormatModifierPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkDrmFormatModifierPropertiesListEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesListEXT* from,
VkDrmFormatModifierPropertiesListEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pDrmFormatModifierProperties = nullptr;
if (from->pDrmFormatModifierProperties)
{
- to->pDrmFormatModifierProperties = (VkDrmFormatModifierPropertiesEXT*)pool->alloc(from->drmFormatModifierCount * sizeof(VkDrmFormatModifierPropertiesEXT));
+ 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(pool, from->pDrmFormatModifierProperties + i, (VkDrmFormatModifierPropertiesEXT*)(to->pDrmFormatModifierProperties + i));
+ deepcopy_VkDrmFormatModifierPropertiesEXT(alloc, rootType, from->pDrmFormatModifierProperties + i, (VkDrmFormatModifierPropertiesEXT*)(to->pDrmFormatModifierProperties + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* from,
VkPhysicalDeviceImageDrmFormatModifierInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+ to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* from,
VkImageDrmFormatModifierListCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pDrmFormatModifiers, from->drmFormatModifierCount * sizeof(const uint64_t));
+ to->pDrmFormatModifiers = (uint64_t*)alloc->dupArray(from->pDrmFormatModifiers, from->drmFormatModifierCount * sizeof(const uint64_t));
}
}
void deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* from,
VkImageDrmFormatModifierExplicitCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pPlaneLayouts = nullptr;
if (from->pPlaneLayouts)
{
- to->pPlaneLayouts = (VkSubresourceLayout*)pool->alloc(from->drmFormatModifierPlaneCount * sizeof(const VkSubresourceLayout));
+ 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(pool, from->pPlaneLayouts + i, (VkSubresourceLayout*)(to->pPlaneLayouts + i));
+ deepcopy_VkSubresourceLayout(alloc, rootType, from->pPlaneLayouts + i, (VkSubresourceLayout*)(to->pPlaneLayouts + i));
}
}
}
}
void deepcopy_VkImageDrmFormatModifierPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageDrmFormatModifierPropertiesEXT* from,
VkImageDrmFormatModifierPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_validation_cache
void deepcopy_VkValidationCacheCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkValidationCacheCreateInfoEXT* from,
VkValidationCacheCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pInitialData = nullptr;
if (from->pInitialData)
{
- to->pInitialData = (void*)pool->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
+ to->pInitialData = (void*)alloc->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
}
}
void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* from,
VkShaderModuleValidationCacheCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -9855,160 +11994,190 @@
#endif
#ifdef VK_NV_shading_rate_image
void deepcopy_VkShadingRatePaletteNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShadingRatePaletteNV* from,
VkShadingRatePaletteNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
to->pShadingRatePaletteEntries = nullptr;
if (from->pShadingRatePaletteEntries)
{
- to->pShadingRatePaletteEntries = (VkShadingRatePaletteEntryNV*)pool->dupArray(from->pShadingRatePaletteEntries, from->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
+ to->pShadingRatePaletteEntries = (VkShadingRatePaletteEntryNV*)alloc->dupArray(from->pShadingRatePaletteEntries, from->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
}
}
void deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* from,
VkPipelineViewportShadingRateImageStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pShadingRatePalettes = nullptr;
if (from->pShadingRatePalettes)
{
- to->pShadingRatePalettes = (VkShadingRatePaletteNV*)pool->alloc(from->viewportCount * sizeof(const VkShadingRatePaletteNV));
+ 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(pool, from->pShadingRatePalettes + i, (VkShadingRatePaletteNV*)(to->pShadingRatePalettes + i));
+ deepcopy_VkShadingRatePaletteNV(alloc, rootType, from->pShadingRatePalettes + i, (VkShadingRatePaletteNV*)(to->pShadingRatePalettes + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* from,
VkPhysicalDeviceShadingRateImageFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* from,
VkPhysicalDeviceShadingRateImagePropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(pool, &from->shadingRateTexelSize, (VkExtent2D*)(&to->shadingRateTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateTexelSize, (VkExtent2D*)(&to->shadingRateTexelSize));
}
void deepcopy_VkCoarseSampleLocationNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCoarseSampleLocationNV* from,
VkCoarseSampleLocationNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkCoarseSampleOrderCustomNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCoarseSampleOrderCustomNV* from,
VkCoarseSampleOrderCustomNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
if (from)
{
to->pSampleLocations = nullptr;
if (from->pSampleLocations)
{
- to->pSampleLocations = (VkCoarseSampleLocationNV*)pool->alloc(from->sampleLocationCount * sizeof(const VkCoarseSampleLocationNV));
+ 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(pool, from->pSampleLocations + i, (VkCoarseSampleLocationNV*)(to->pSampleLocations + i));
+ deepcopy_VkCoarseSampleLocationNV(alloc, rootType, from->pSampleLocations + i, (VkCoarseSampleLocationNV*)(to->pSampleLocations + i));
}
}
}
}
void deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* from,
VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pCustomSampleOrders = nullptr;
if (from->pCustomSampleOrders)
{
- to->pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)pool->alloc(from->customSampleOrderCount * sizeof(const VkCoarseSampleOrderCustomNV));
+ 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(pool, from->pCustomSampleOrders + i, (VkCoarseSampleOrderCustomNV*)(to->pCustomSampleOrders + i));
+ deepcopy_VkCoarseSampleOrderCustomNV(alloc, rootType, from->pCustomSampleOrders + i, (VkCoarseSampleOrderCustomNV*)(to->pCustomSampleOrders + i));
}
}
}
@@ -10017,57 +12186,69 @@
#endif
#ifdef VK_NV_ray_tracing
void deepcopy_VkRayTracingShaderGroupCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoNV* from,
VkRayTracingShaderGroupCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkRayTracingPipelineCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoNV* from,
VkRayTracingPipelineCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pStages = nullptr;
if (from->pStages)
{
- to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ 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(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
}
}
}
@@ -10076,368 +12257,454 @@
to->pGroups = nullptr;
if (from->pGroups)
{
- to->pGroups = (VkRayTracingShaderGroupCreateInfoNV*)pool->alloc(from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoNV));
+ 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(pool, from->pGroups + i, (VkRayTracingShaderGroupCreateInfoNV*)(to->pGroups + i));
+ deepcopy_VkRayTracingShaderGroupCreateInfoNV(alloc, rootType, from->pGroups + i, (VkRayTracingShaderGroupCreateInfoNV*)(to->pGroups + i));
}
}
}
}
void deepcopy_VkGeometryTrianglesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeometryTrianglesNV* from,
VkGeometryTrianglesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkGeometryAABBNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeometryAABBNV* from,
VkGeometryAABBNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkGeometryDataNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeometryDataNV* from,
VkGeometryDataNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkGeometryTrianglesNV(pool, &from->triangles, (VkGeometryTrianglesNV*)(&to->triangles));
- deepcopy_VkGeometryAABBNV(pool, &from->aabbs, (VkGeometryAABBNV*)(&to->aabbs));
+ deepcopy_VkGeometryTrianglesNV(alloc, rootType, &from->triangles, (VkGeometryTrianglesNV*)(&to->triangles));
+ deepcopy_VkGeometryAABBNV(alloc, rootType, &from->aabbs, (VkGeometryAABBNV*)(&to->aabbs));
}
void deepcopy_VkGeometryNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeometryNV* from,
VkGeometryNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkGeometryDataNV(pool, &from->geometry, (VkGeometryDataNV*)(&to->geometry));
+ deepcopy_VkGeometryDataNV(alloc, rootType, &from->geometry, (VkGeometryDataNV*)(&to->geometry));
}
void deepcopy_VkAccelerationStructureInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureInfoNV* from,
VkAccelerationStructureInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pGeometries = nullptr;
if (from->pGeometries)
{
- to->pGeometries = (VkGeometryNV*)pool->alloc(from->geometryCount * sizeof(const VkGeometryNV));
+ 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(pool, from->pGeometries + i, (VkGeometryNV*)(to->pGeometries + i));
+ deepcopy_VkGeometryNV(alloc, rootType, from->pGeometries + i, (VkGeometryNV*)(to->pGeometries + i));
}
}
}
}
void deepcopy_VkAccelerationStructureCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoNV* from,
VkAccelerationStructureCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkAccelerationStructureInfoNV(pool, &from->info, (VkAccelerationStructureInfoNV*)(&to->info));
+ deepcopy_VkAccelerationStructureInfoNV(alloc, rootType, &from->info, (VkAccelerationStructureInfoNV*)(&to->info));
}
void deepcopy_VkBindAccelerationStructureMemoryInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindAccelerationStructureMemoryInfoNV* from,
VkBindAccelerationStructureMemoryInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
+ to->pDeviceIndices = (uint32_t*)alloc->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkWriteDescriptorSetAccelerationStructureNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* from,
VkWriteDescriptorSetAccelerationStructureNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAccelerationStructures = nullptr;
if (from->pAccelerationStructures)
{
- to->pAccelerationStructures = (VkAccelerationStructureNV*)pool->dupArray(from->pAccelerationStructures, from->accelerationStructureCount * sizeof(const VkAccelerationStructureNV));
+ to->pAccelerationStructures = (VkAccelerationStructureNV*)alloc->dupArray(from->pAccelerationStructures, from->accelerationStructureCount * sizeof(const VkAccelerationStructureNV));
}
}
void deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* from,
VkAccelerationStructureMemoryRequirementsInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPropertiesNV* from,
VkPhysicalDeviceRayTracingPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkTransformMatrixKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkTransformMatrixKHR* from,
VkTransformMatrixKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
memcpy(to->matrix, from->matrix, ((3)*(4)) * sizeof(float));
}
void deepcopy_VkAabbPositionsKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAabbPositionsKHR* from,
VkAabbPositionsKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkAccelerationStructureInstanceKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureInstanceKHR* from,
VkAccelerationStructureInstanceKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkTransformMatrixKHR(pool, &from->transform, (VkTransformMatrixKHR*)(&to->transform));
+ deepcopy_VkTransformMatrixKHR(alloc, rootType, &from->transform, (VkTransformMatrixKHR*)(&to->transform));
}
#endif
#ifdef VK_NV_representative_fragment_test
void deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* from,
VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* from,
VkPipelineRepresentativeFragmentTestStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_filter_cubic
void deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* from,
VkPhysicalDeviceImageViewImageFormatInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* from,
VkFilterCubicImageViewImageFormatPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -10446,97 +12713,121 @@
#endif
#ifdef VK_EXT_global_priority
void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
VkDeviceQueueGlobalPriorityCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_external_memory_host
void deepcopy_VkImportMemoryHostPointerInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportMemoryHostPointerInfoEXT* from,
VkImportMemoryHostPointerInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pHostPointer = nullptr;
if (from->pHostPointer)
{
- to->pHostPointer = (void*)pool->dupArray(from->pHostPointer, sizeof(uint8_t));
+ to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(uint8_t));
}
}
void deepcopy_VkMemoryHostPointerPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryHostPointerPropertiesEXT* from,
VkMemoryHostPointerPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -10545,260 +12836,318 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void deepcopy_VkPipelineCompilerControlCreateInfoAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* from,
VkPipelineCompilerControlCreateInfoAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_calibrated_timestamps
void deepcopy_VkCalibratedTimestampInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCalibratedTimestampInfoEXT* from,
VkCalibratedTimestampInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_AMD_shader_core_properties
void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* from,
VkPhysicalDeviceShaderCorePropertiesAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* from,
VkDeviceMemoryOverallocationCreateInfoAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* from,
VkVertexInputBindingDivisorDescriptionEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
VkPipelineVertexInputDivisorStateCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pVertexBindingDivisors = nullptr;
if (from->pVertexBindingDivisors)
{
- to->pVertexBindingDivisors = (VkVertexInputBindingDivisorDescriptionEXT*)pool->alloc(from->vertexBindingDivisorCount * sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
+ 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(pool, from->pVertexBindingDivisors + i, (VkVertexInputBindingDivisorDescriptionEXT*)(to->pVertexBindingDivisors + i));
+ deepcopy_VkVertexInputBindingDivisorDescriptionEXT(alloc, rootType, from->pVertexBindingDivisors + i, (VkVertexInputBindingDivisorDescriptionEXT*)(to->pVertexBindingDivisors + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* from,
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_GGP_frame_token
void deepcopy_VkPresentFrameTokenGGP(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentFrameTokenGGP* from,
VkPresentFrameTokenGGP* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
void deepcopy_VkPipelineCreationFeedbackEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackEXT* from,
VkPipelineCreationFeedbackEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackCreateInfoEXT* from,
VkPipelineCreationFeedbackCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pPipelineCreationFeedback = nullptr;
if (from->pPipelineCreationFeedback)
{
- to->pPipelineCreationFeedback = (VkPipelineCreationFeedbackEXT*)pool->alloc(sizeof(VkPipelineCreationFeedbackEXT));
- deepcopy_VkPipelineCreationFeedbackEXT(pool, from->pPipelineCreationFeedback, (VkPipelineCreationFeedbackEXT*)(to->pPipelineCreationFeedback));
+ to->pPipelineCreationFeedback = (VkPipelineCreationFeedbackEXT*)alloc->alloc(sizeof(VkPipelineCreationFeedbackEXT));
+ deepcopy_VkPipelineCreationFeedbackEXT(alloc, rootType, from->pPipelineCreationFeedback, (VkPipelineCreationFeedbackEXT*)(to->pPipelineCreationFeedback));
}
if (from)
{
to->pPipelineStageCreationFeedbacks = nullptr;
if (from->pPipelineStageCreationFeedbacks)
{
- to->pPipelineStageCreationFeedbacks = (VkPipelineCreationFeedbackEXT*)pool->alloc(from->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedbackEXT));
+ 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(pool, from->pPipelineStageCreationFeedbacks + i, (VkPipelineCreationFeedbackEXT*)(to->pPipelineStageCreationFeedbacks + i));
+ deepcopy_VkPipelineCreationFeedbackEXT(alloc, rootType, from->pPipelineStageCreationFeedbacks + i, (VkPipelineCreationFeedbackEXT*)(to->pPipelineStageCreationFeedbacks + i));
}
}
}
@@ -10809,618 +13158,771 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* from,
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_mesh_shader
void deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderFeaturesNV* from,
VkPhysicalDeviceMeshShaderFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderPropertiesNV* from,
VkPhysicalDeviceMeshShaderPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->maxTaskWorkGroupSize, from->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
memcpy(to->maxMeshWorkGroupSize, from->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
}
void deepcopy_VkDrawMeshTasksIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrawMeshTasksIndirectCommandNV* from,
VkDrawMeshTasksIndirectCommandNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* from,
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_shader_image_footprint
void deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* from,
VkPhysicalDeviceShaderImageFootprintFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_scissor_exclusive
void deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* from,
VkPipelineViewportExclusiveScissorStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pExclusiveScissors = nullptr;
if (from->pExclusiveScissors)
{
- to->pExclusiveScissors = (VkRect2D*)pool->alloc(from->exclusiveScissorCount * sizeof(const VkRect2D));
+ 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(pool, from->pExclusiveScissors + i, (VkRect2D*)(to->pExclusiveScissors + i));
+ deepcopy_VkRect2D(alloc, rootType, from->pExclusiveScissors + i, (VkRect2D*)(to->pExclusiveScissors + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* from,
VkPhysicalDeviceExclusiveScissorFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueueFamilyCheckpointPropertiesNV* from,
VkQueueFamilyCheckpointPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCheckpointDataNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCheckpointDataNV* from,
VkCheckpointDataNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCheckpointMarker = nullptr;
if (from->pCheckpointMarker)
{
- to->pCheckpointMarker = (void*)pool->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
+ to->pCheckpointMarker = (void*)alloc->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
}
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
void deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* from,
VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_INTEL_performance_query
void deepcopy_VkPerformanceValueDataINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceValueDataINTEL* from,
VkPerformanceValueDataINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
to->valueString = nullptr;
if (from->valueString)
{
- to->valueString = pool->strDup(from->valueString);
+ to->valueString = alloc->strDup(from->valueString);
}
}
void deepcopy_VkPerformanceValueINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceValueINTEL* from,
VkPerformanceValueINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkPerformanceValueDataINTEL(pool, &from->data, (VkPerformanceValueDataINTEL*)(&to->data));
+ deepcopy_VkPerformanceValueDataINTEL(alloc, rootType, &from->data, (VkPerformanceValueDataINTEL*)(&to->data));
}
void deepcopy_VkInitializePerformanceApiInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkInitializePerformanceApiInfoINTEL* from,
VkInitializePerformanceApiInfoINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pUserData = nullptr;
if (from->pUserData)
{
- to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+ to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
void deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* from,
VkQueryPoolPerformanceQueryCreateInfoINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPerformanceMarkerInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceMarkerInfoINTEL* from,
VkPerformanceMarkerInfoINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPerformanceStreamMarkerInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceStreamMarkerInfoINTEL* from,
VkPerformanceStreamMarkerInfoINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPerformanceOverrideInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceOverrideInfoINTEL* from,
VkPerformanceOverrideInfoINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* from,
VkPerformanceConfigurationAcquireInfoINTEL* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_pci_bus_info
void deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* from,
VkPhysicalDevicePCIBusInfoPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_AMD_display_native_hdr
void deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* from,
VkDisplayNativeHdrSurfaceCapabilitiesAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* from,
VkSwapchainDisplayNativeHdrCreateInfoAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImagePipeSurfaceCreateInfoFUCHSIA* from,
VkImagePipeSurfaceCreateInfoFUCHSIA* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_metal_surface
void deepcopy_VkMetalSurfaceCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMetalSurfaceCreateInfoEXT* from,
VkMetalSurfaceCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pLayer = nullptr;
if (from->pLayer)
{
- to->pLayer = (CAMetalLayer*)pool->dupArray(from->pLayer, sizeof(const CAMetalLayer));
+ to->pLayer = (CAMetalLayer*)alloc->dupArray(from->pLayer, sizeof(const CAMetalLayer));
}
}
#endif
-#ifdef VK_GOOGLE_color_buffer
-void deepcopy_VkImportColorBufferGOOGLE(
- BumpPool* pool,
- const VkImportColorBufferGOOGLE* from,
- VkImportColorBufferGOOGLE* to)
+#ifdef VK_EXT_fragment_density_map
+void deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ Allocator* alloc,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* from,
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImportBufferGOOGLE(
- BumpPool* pool,
- const VkImportBufferGOOGLE* from,
- VkImportBufferGOOGLE* to)
+void deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ Allocator* alloc,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* from,
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ 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));
}
-void deepcopy_VkImportPhysicalAddressGOOGLE(
- BumpPool* pool,
- const VkImportPhysicalAddressGOOGLE* from,
- VkImportPhysicalAddressGOOGLE* to)
+void deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ Allocator* alloc,
+ VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* from,
+ VkRenderPassFragmentDensityMapCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
+ deepcopy_VkAttachmentReference(alloc, rootType, &from->fragmentDensityMapAttachment, (VkAttachmentReference*)(&to->fragmentDensityMapAttachment));
}
#endif
@@ -11432,164 +13934,206 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* from,
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* from,
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* from,
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_AMD_shader_core_properties2
void deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* from,
VkPhysicalDeviceShaderCoreProperties2AMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_AMD_device_coherent_memory
void deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* from,
VkPhysicalDeviceCoherentMemoryFeaturesAMD* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* from,
VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_memory_budget
void deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* from,
VkPhysicalDeviceMemoryBudgetPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->heapBudget, from->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
memcpy(to->heapUsage, from->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
@@ -11598,140 +14142,176 @@
#endif
#ifdef VK_EXT_memory_priority
void deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* from,
VkPhysicalDeviceMemoryPriorityFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryPriorityAllocateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryPriorityAllocateInfoEXT* from,
VkMemoryPriorityAllocateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* from,
VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_buffer_device_address
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* from,
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBufferDeviceAddressCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferDeviceAddressCreateInfoEXT* from,
VkBufferDeviceAddressCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_tooling_info
void deepcopy_VkPhysicalDeviceToolPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceToolPropertiesEXT* from,
VkPhysicalDeviceToolPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->name, from->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
memcpy(to->version, from->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
@@ -11744,402 +14324,504 @@
#endif
#ifdef VK_EXT_validation_features
void deepcopy_VkValidationFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkValidationFeaturesEXT* from,
VkValidationFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pEnabledValidationFeatures = nullptr;
if (from->pEnabledValidationFeatures)
{
- to->pEnabledValidationFeatures = (VkValidationFeatureEnableEXT*)pool->dupArray(from->pEnabledValidationFeatures, from->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
+ to->pEnabledValidationFeatures = (VkValidationFeatureEnableEXT*)alloc->dupArray(from->pEnabledValidationFeatures, from->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
}
to->pDisabledValidationFeatures = nullptr;
if (from->pDisabledValidationFeatures)
{
- to->pDisabledValidationFeatures = (VkValidationFeatureDisableEXT*)pool->dupArray(from->pDisabledValidationFeatures, from->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT));
+ to->pDisabledValidationFeatures = (VkValidationFeatureDisableEXT*)alloc->dupArray(from->pDisabledValidationFeatures, from->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT));
}
}
#endif
#ifdef VK_NV_cooperative_matrix
void deepcopy_VkCooperativeMatrixPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCooperativeMatrixPropertiesNV* from,
VkCooperativeMatrixPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* from,
VkPhysicalDeviceCooperativeMatrixFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* from,
VkPhysicalDeviceCooperativeMatrixPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_coverage_reduction_mode
void deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* from,
VkPhysicalDeviceCoverageReductionModeFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* from,
VkPipelineCoverageReductionStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkFramebufferMixedSamplesCombinationNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* from,
VkFramebufferMixedSamplesCombinationNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
void deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* from,
VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* from,
VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_full_screen_exclusive
void deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveInfoEXT* from,
VkSurfaceFullScreenExclusiveInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* from,
VkSurfaceCapabilitiesFullScreenExclusiveEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* from,
VkSurfaceFullScreenExclusiveWin32InfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_headless_surface
void deepcopy_VkHeadlessSurfaceCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkHeadlessSurfaceCreateInfoEXT* from,
VkHeadlessSurfaceCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_line_rasterization
void deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* from,
VkPhysicalDeviceLineRasterizationFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* from,
VkPhysicalDeviceLineRasterizationPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* from,
VkPipelineRasterizationLineStateCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_shader_atomic_float
void deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* from,
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -12148,660 +14830,808 @@
#endif
#ifdef VK_EXT_index_type_uint8
void deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* from,
VkPhysicalDeviceIndexTypeUint8FeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_extended_dynamic_state
void deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* from,
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* from,
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_device_generated_commands
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* from,
VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* from,
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkGraphicsShaderGroupCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGraphicsShaderGroupCreateInfoNV* from,
VkGraphicsShaderGroupCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pStages = nullptr;
if (from->pStages)
{
- to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ 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(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
}
}
}
to->pVertexInputState = nullptr;
if (from->pVertexInputState)
{
- to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)pool->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
- deepcopy_VkPipelineVertexInputStateCreateInfo(pool, from->pVertexInputState, (VkPipelineVertexInputStateCreateInfo*)(to->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*)pool->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
- deepcopy_VkPipelineTessellationStateCreateInfo(pool, from->pTessellationState, (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
+ to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
+ deepcopy_VkPipelineTessellationStateCreateInfo(alloc, rootType, from->pTessellationState, (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
}
}
void deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* from,
VkGraphicsPipelineShaderGroupsCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pGroups = nullptr;
if (from->pGroups)
{
- to->pGroups = (VkGraphicsShaderGroupCreateInfoNV*)pool->alloc(from->groupCount * sizeof(const VkGraphicsShaderGroupCreateInfoNV));
+ 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(pool, from->pGroups + i, (VkGraphicsShaderGroupCreateInfoNV*)(to->pGroups + i));
+ deepcopy_VkGraphicsShaderGroupCreateInfoNV(alloc, rootType, from->pGroups + i, (VkGraphicsShaderGroupCreateInfoNV*)(to->pGroups + i));
}
}
}
to->pPipelines = nullptr;
if (from->pPipelines)
{
- to->pPipelines = (VkPipeline*)pool->dupArray(from->pPipelines, from->pipelineCount * sizeof(const VkPipeline));
+ to->pPipelines = (VkPipeline*)alloc->dupArray(from->pPipelines, from->pipelineCount * sizeof(const VkPipeline));
}
}
void deepcopy_VkBindShaderGroupIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindShaderGroupIndirectCommandNV* from,
VkBindShaderGroupIndirectCommandNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkBindIndexBufferIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindIndexBufferIndirectCommandNV* from,
VkBindIndexBufferIndirectCommandNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkBindVertexBufferIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindVertexBufferIndirectCommandNV* from,
VkBindVertexBufferIndirectCommandNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkSetStateFlagsIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSetStateFlagsIndirectCommandNV* from,
VkSetStateFlagsIndirectCommandNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkIndirectCommandsStreamNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkIndirectCommandsStreamNV* from,
VkIndirectCommandsStreamNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkIndirectCommandsLayoutTokenNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutTokenNV* from,
VkIndirectCommandsLayoutTokenNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pIndexTypes = nullptr;
if (from->pIndexTypes)
{
- to->pIndexTypes = (VkIndexType*)pool->dupArray(from->pIndexTypes, from->indexTypeCount * sizeof(const VkIndexType));
+ to->pIndexTypes = (VkIndexType*)alloc->dupArray(from->pIndexTypes, from->indexTypeCount * sizeof(const VkIndexType));
}
to->pIndexTypeValues = nullptr;
if (from->pIndexTypeValues)
{
- to->pIndexTypeValues = (uint32_t*)pool->dupArray(from->pIndexTypeValues, from->indexTypeCount * sizeof(const uint32_t));
+ to->pIndexTypeValues = (uint32_t*)alloc->dupArray(from->pIndexTypeValues, from->indexTypeCount * sizeof(const uint32_t));
}
}
void deepcopy_VkIndirectCommandsLayoutCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutCreateInfoNV* from,
VkIndirectCommandsLayoutCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pTokens = nullptr;
if (from->pTokens)
{
- to->pTokens = (VkIndirectCommandsLayoutTokenNV*)pool->alloc(from->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNV));
+ 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(pool, from->pTokens + i, (VkIndirectCommandsLayoutTokenNV*)(to->pTokens + i));
+ deepcopy_VkIndirectCommandsLayoutTokenNV(alloc, rootType, from->pTokens + i, (VkIndirectCommandsLayoutTokenNV*)(to->pTokens + i));
}
}
}
to->pStreamStrides = nullptr;
if (from->pStreamStrides)
{
- to->pStreamStrides = (uint32_t*)pool->dupArray(from->pStreamStrides, from->streamCount * sizeof(const uint32_t));
+ to->pStreamStrides = (uint32_t*)alloc->dupArray(from->pStreamStrides, from->streamCount * sizeof(const uint32_t));
}
}
void deepcopy_VkGeneratedCommandsInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeneratedCommandsInfoNV* from,
VkGeneratedCommandsInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pStreams = nullptr;
if (from->pStreams)
{
- to->pStreams = (VkIndirectCommandsStreamNV*)pool->alloc(from->streamCount * sizeof(const VkIndirectCommandsStreamNV));
+ 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(pool, from->pStreams + i, (VkIndirectCommandsStreamNV*)(to->pStreams + i));
+ deepcopy_VkIndirectCommandsStreamNV(alloc, rootType, from->pStreams + i, (VkIndirectCommandsStreamNV*)(to->pStreams + i));
}
}
}
}
void deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* from,
VkGeneratedCommandsMemoryRequirementsInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* from,
VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* from,
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_QCOM_render_pass_transform
void deepcopy_VkRenderPassTransformBeginInfoQCOM(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassTransformBeginInfoQCOM* from,
VkRenderPassTransformBeginInfoQCOM* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* from,
VkCommandBufferInheritanceRenderPassTransformInfoQCOM* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkRect2D(pool, &from->renderArea, (VkRect2D*)(&to->renderArea));
+ deepcopy_VkRect2D(alloc, rootType, &from->renderArea, (VkRect2D*)(&to->renderArea));
}
#endif
#ifdef VK_EXT_device_memory_report
void deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* from,
VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceMemoryReportCallbackDataEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceMemoryReportCallbackDataEXT* from,
VkDeviceMemoryReportCallbackDataEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* from,
VkDeviceDeviceMemoryReportCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pUserData = nullptr;
if (from->pUserData)
{
- to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+ to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
#endif
#ifdef VK_EXT_robustness2
void deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2FeaturesEXT* from,
VkPhysicalDeviceRobustness2FeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* from,
VkPhysicalDeviceRobustness2PropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_custom_border_color
void deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerCustomBorderColorCreateInfoEXT* from,
VkSamplerCustomBorderColorCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkClearColorValue(pool, &from->customBorderColor, (VkClearColorValue*)(&to->customBorderColor));
+ deepcopy_VkClearColorValue(alloc, rootType, &from->customBorderColor, (VkClearColorValue*)(&to->customBorderColor));
}
void deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* from,
VkPhysicalDeviceCustomBorderColorPropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* from,
VkPhysicalDeviceCustomBorderColorFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -12810,138 +15640,174 @@
#endif
#ifdef VK_EXT_private_data
void deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePrivateDataFeaturesEXT* from,
VkPhysicalDevicePrivateDataFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDevicePrivateDataCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDevicePrivateDataCreateInfoEXT* from,
VkDevicePrivateDataCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPrivateDataSlotCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPrivateDataSlotCreateInfoEXT* from,
VkPrivateDataSlotCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* from,
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_NV_device_diagnostics_config
void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* from,
VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceDiagnosticsConfigCreateInfoNV* from,
VkDeviceDiagnosticsConfigCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
@@ -12950,68 +15816,86 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* from,
VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* from,
VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* from,
VkPipelineFragmentShadingRateEnumStateCreateInfoNV* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->combinerOps, from->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}
@@ -13019,651 +15903,887 @@
#endif
#ifdef VK_EXT_fragment_density_map2
void deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* from,
VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* from,
VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
void deepcopy_VkCopyCommandTransformInfoQCOM(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyCommandTransformInfoQCOM* from,
VkCopyCommandTransformInfoQCOM* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_image_robustness
void deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* from,
VkPhysicalDeviceImageRobustnessFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_4444_formats
void deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* from,
VkPhysicalDevice4444FormatsFeaturesEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_EXT_directfb_surface
void deepcopy_VkDirectFBSurfaceCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDirectFBSurfaceCreateInfoEXT* from,
VkDirectFBSurfaceCreateInfoEXT* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->dfb = nullptr;
if (from->dfb)
{
- to->dfb = (IDirectFB*)pool->dupArray(from->dfb, sizeof(IDirectFB));
+ to->dfb = (IDirectFB*)alloc->dupArray(from->dfb, sizeof(IDirectFB));
}
to->surface = nullptr;
if (from->surface)
{
- to->surface = (IDirectFBSurface*)pool->dupArray(from->surface, sizeof(IDirectFBSurface));
+ to->surface = (IDirectFBSurface*)alloc->dupArray(from->surface, sizeof(IDirectFBSurface));
}
}
#endif
#ifdef VK_GOOGLE_gfxstream
+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)
+ {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext)
+ {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ 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)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext)
+ {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ 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)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext)
+ {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
#endif
#ifdef VK_KHR_acceleration_structure
void deepcopy_VkDeviceOrHostAddressKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceOrHostAddressKHR* from,
VkDeviceOrHostAddressKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
to->hostAddress = nullptr;
if (from->hostAddress)
{
- to->hostAddress = (void*)pool->dupArray(from->hostAddress, sizeof(uint8_t));
+ to->hostAddress = (void*)alloc->dupArray(from->hostAddress, sizeof(uint8_t));
}
}
void deepcopy_VkDeviceOrHostAddressConstKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceOrHostAddressConstKHR* from,
VkDeviceOrHostAddressConstKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
to->hostAddress = nullptr;
if (from->hostAddress)
{
- to->hostAddress = (void*)pool->dupArray(from->hostAddress, sizeof(const uint8_t));
+ to->hostAddress = (void*)alloc->dupArray(from->hostAddress, sizeof(const uint8_t));
}
}
void deepcopy_VkAccelerationStructureBuildRangeInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* from,
VkAccelerationStructureBuildRangeInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* from,
VkAccelerationStructureGeometryTrianglesDataKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->vertexData, (VkDeviceOrHostAddressConstKHR*)(&to->vertexData));
- deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->indexData, (VkDeviceOrHostAddressConstKHR*)(&to->indexData));
- deepcopy_VkDeviceOrHostAddressConstKHR(pool, &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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryAabbsDataKHR* from,
VkAccelerationStructureGeometryAabbsDataKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->data, (VkDeviceOrHostAddressConstKHR*)(&to->data));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->data, (VkDeviceOrHostAddressConstKHR*)(&to->data));
}
void deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* from,
VkAccelerationStructureGeometryInstancesDataKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->data, (VkDeviceOrHostAddressConstKHR*)(&to->data));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->data, (VkDeviceOrHostAddressConstKHR*)(&to->data));
}
void deepcopy_VkAccelerationStructureGeometryDataKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryDataKHR* from,
VkAccelerationStructureGeometryDataKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
- deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(pool, &from->triangles, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&to->triangles));
- deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(pool, &from->aabbs, (VkAccelerationStructureGeometryAabbsDataKHR*)(&to->aabbs));
- deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(pool, &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(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryKHR* from,
VkAccelerationStructureGeometryKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkAccelerationStructureGeometryDataKHR(pool, &from->geometry, (VkAccelerationStructureGeometryDataKHR*)(&to->geometry));
+ deepcopy_VkAccelerationStructureGeometryDataKHR(alloc, rootType, &from->geometry, (VkAccelerationStructureGeometryDataKHR*)(&to->geometry));
}
void deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureBuildGeometryInfoKHR* from,
VkAccelerationStructureBuildGeometryInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pGeometries = nullptr;
if (from->pGeometries)
{
- to->pGeometries = (VkAccelerationStructureGeometryKHR*)pool->alloc(from->geometryCount * sizeof(const VkAccelerationStructureGeometryKHR));
+ 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(pool, from->pGeometries + i, (VkAccelerationStructureGeometryKHR*)(to->pGeometries + i));
+ deepcopy_VkAccelerationStructureGeometryKHR(alloc, rootType, from->pGeometries + i, (VkAccelerationStructureGeometryKHR*)(to->pGeometries + i));
}
}
}
- deepcopy_VkDeviceOrHostAddressKHR(pool, &from->scratchData, (VkDeviceOrHostAddressKHR*)(&to->scratchData));
+ deepcopy_VkDeviceOrHostAddressKHR(alloc, rootType, &from->scratchData, (VkDeviceOrHostAddressKHR*)(&to->scratchData));
}
void deepcopy_VkAccelerationStructureCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoKHR* from,
VkAccelerationStructureCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* from,
VkWriteDescriptorSetAccelerationStructureKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAccelerationStructures = nullptr;
if (from->pAccelerationStructures)
{
- to->pAccelerationStructures = (VkAccelerationStructureKHR*)pool->dupArray(from->pAccelerationStructures, from->accelerationStructureCount * sizeof(const VkAccelerationStructureKHR));
+ to->pAccelerationStructures = (VkAccelerationStructureKHR*)alloc->dupArray(from->pAccelerationStructures, from->accelerationStructureCount * sizeof(const VkAccelerationStructureKHR));
}
}
void deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* from,
VkPhysicalDeviceAccelerationStructureFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* from,
VkPhysicalDeviceAccelerationStructurePropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* from,
VkAccelerationStructureDeviceAddressInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAccelerationStructureVersionInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureVersionInfoKHR* from,
VkAccelerationStructureVersionInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const 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*)pool->dupArray(from->pVersionData, 2*VK_UUID_SIZE * sizeof(const uint8_t));
+ to->pVersionData = (uint8_t*)alloc->dupArray(from->pVersionData, 2*VK_UUID_SIZE * sizeof(const uint8_t));
}
}
void deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* from,
VkCopyAccelerationStructureToMemoryInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressKHR(pool, &from->dst, (VkDeviceOrHostAddressKHR*)(&to->dst));
+ deepcopy_VkDeviceOrHostAddressKHR(alloc, rootType, &from->dst, (VkDeviceOrHostAddressKHR*)(&to->dst));
}
void deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyMemoryToAccelerationStructureInfoKHR* from,
VkCopyMemoryToAccelerationStructureInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(pool, &from->src, (VkDeviceOrHostAddressConstKHR*)(&to->src));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->src, (VkDeviceOrHostAddressConstKHR*)(&to->src));
}
void deepcopy_VkCopyAccelerationStructureInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyAccelerationStructureInfoKHR* from,
VkCopyAccelerationStructureInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAccelerationStructureBuildSizesInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* from,
VkAccelerationStructureBuildSizesInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoKHR* from,
VkRayTracingShaderGroupCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pShaderGroupCaptureReplayHandle = nullptr;
if (from->pShaderGroupCaptureReplayHandle)
{
- to->pShaderGroupCaptureReplayHandle = (void*)pool->dupArray(from->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
+ to->pShaderGroupCaptureReplayHandle = (void*)alloc->dupArray(from->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
}
}
void deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* from,
VkRayTracingPipelineInterfaceCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkRayTracingPipelineCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoKHR* from,
VkRayTracingPipelineCreateInfoKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (const void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (const void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
if (from)
{
to->pStages = nullptr;
if (from->pStages)
{
- to->pStages = (VkPipelineShaderStageCreateInfo*)pool->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ 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(pool, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
}
}
}
@@ -13672,123 +16792,146 @@
to->pGroups = nullptr;
if (from->pGroups)
{
- to->pGroups = (VkRayTracingShaderGroupCreateInfoKHR*)pool->alloc(from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoKHR));
+ 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(pool, from->pGroups + i, (VkRayTracingShaderGroupCreateInfoKHR*)(to->pGroups + i));
+ deepcopy_VkRayTracingShaderGroupCreateInfoKHR(alloc, rootType, from->pGroups + i, (VkRayTracingShaderGroupCreateInfoKHR*)(to->pGroups + i));
}
}
}
to->pLibraryInfo = nullptr;
if (from->pLibraryInfo)
{
- to->pLibraryInfo = (VkPipelineLibraryCreateInfoKHR*)pool->alloc(sizeof(const VkPipelineLibraryCreateInfoKHR));
- deepcopy_VkPipelineLibraryCreateInfoKHR(pool, from->pLibraryInfo, (VkPipelineLibraryCreateInfoKHR*)(to->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*)pool->alloc(sizeof(const VkRayTracingPipelineInterfaceCreateInfoKHR));
- deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(pool, from->pLibraryInterface, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(to->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*)pool->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
- deepcopy_VkPipelineDynamicStateCreateInfo(pool, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
+ to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
+ deepcopy_VkPipelineDynamicStateCreateInfo(alloc, rootType, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
}
}
void deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* from,
VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* from,
VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkStridedDeviceAddressRegionKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkStridedDeviceAddressRegionKHR* from,
VkStridedDeviceAddressRegionKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
void deepcopy_VkTraceRaysIndirectCommandKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkTraceRaysIndirectCommandKHR* from,
VkTraceRaysIndirectCommandKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
}
#endif
#ifdef VK_KHR_ray_query
void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRayQueryFeaturesKHR* from,
VkPhysicalDeviceRayQueryFeaturesKHR* to)
{
- (void)pool;
+ (void)alloc;
+ (void)rootType;
*to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = from->sType;
+ }
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext)
{
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(from_pNext);
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
if (pNext_size)
{
- to->pNext = (void*)pool->alloc(pNext_size);
- deepcopy_extension_struct(pool, from_pNext, (void*)(to->pNext));
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
void deepcopy_extension_struct(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const void* structExtension,
void* structExtension_out)
{
@@ -13802,1535 +16945,1613 @@
#ifdef VK_VERSION_1_1
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
{
- deepcopy_VkPhysicalDeviceSubgroupProperties(pool, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ deepcopy_VkPhysicalDevice16BitStorageFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
{
- deepcopy_VkMemoryDedicatedRequirements(pool, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension), reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ deepcopy_VkPhysicalDeviceProtectedMemoryProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
{
- deepcopy_VkProtectedSubmitInfo(pool, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension), reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+ deepcopy_VkDisplayPresentInfoKHR(alloc, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- deepcopy_VkImportMemoryWin32HandleInfoKHR(pool, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension), reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension), reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension), reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension), reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension), reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
+ deepcopy_VkSurfaceProtectedCapabilitiesKHR(alloc, rootType, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
{
- deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
+ deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
{
- deepcopy_VkNativeBufferANDROID(pool, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension), reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
+ deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
{
- deepcopy_VkTextureLODGatherFormatPropertiesAMD(pool, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension), reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension), reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ deepcopy_VkImportAndroidHardwareBufferInfoANDROID(alloc, rootType, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
{
- deepcopy_VkExternalFormatANDROID(pool, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ deepcopy_VkExternalFormatANDROID(alloc, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
{
- deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension), reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension), reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension), reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension), reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension), reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
+ deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_cache
case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
{
- deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(pool, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension), reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension), reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension), reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension), reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+ deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
{
- deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(pool, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension), reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension), reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension), reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
+ deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(alloc, rootType, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
break;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- deepcopy_VkImportColorBufferGOOGLE(pool, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ 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));
+ break;
+ }
+ 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));
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- deepcopy_VkImportBufferGOOGLE(pool, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ 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));
+ break;
+ }
+ default:
+ {
+ deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- deepcopy_VkImportPhysicalAddressGOOGLE(pool, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ 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));
+ break;
+ }
+ 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));
+ break;
+ }
+ }
break;
}
#endif
#ifdef VK_EXT_subgroup_size_control
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
{
- deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension), reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
+ deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
{
- deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(pool, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension), reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension), reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension_out));
+ deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(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(pool, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
+ deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(alloc, rootType, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
{
- deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension), reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension), reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension), reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension), reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
+ deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
{
- deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
+ deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(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));
+ break;
+ }
+ 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));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
- deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(pool, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension_out));
+ 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(pool, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
+ deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
break;
}
#endif
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
index ef555eb..d1e8c10 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -31,6 +31,7 @@
#include "goldfish_vk_private_defs.h"
#include "android/base/BumpPool.h"
+using android::base::Allocator;
using android::base::BumpPool;
// Stuff we are not going to use but if included,
// will cause compile errors. These are Android Vulkan
@@ -44,891 +45,1068 @@
#ifdef VK_VERSION_1_0
void deepcopy_VkExtent2D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExtent2D* from,
VkExtent2D* to);
void deepcopy_VkExtent3D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExtent3D* from,
VkExtent3D* to);
void deepcopy_VkOffset2D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkOffset2D* from,
VkOffset2D* to);
void deepcopy_VkOffset3D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkOffset3D* from,
VkOffset3D* to);
void deepcopy_VkRect2D(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRect2D* from,
VkRect2D* to);
void deepcopy_VkBaseInStructure(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBaseInStructure* from,
VkBaseInStructure* to);
void deepcopy_VkBaseOutStructure(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBaseOutStructure* from,
VkBaseOutStructure* to);
void deepcopy_VkBufferMemoryBarrier(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferMemoryBarrier* from,
VkBufferMemoryBarrier* to);
void deepcopy_VkDispatchIndirectCommand(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDispatchIndirectCommand* from,
VkDispatchIndirectCommand* to);
void deepcopy_VkDrawIndexedIndirectCommand(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrawIndexedIndirectCommand* from,
VkDrawIndexedIndirectCommand* to);
void deepcopy_VkDrawIndirectCommand(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrawIndirectCommand* from,
VkDrawIndirectCommand* to);
void deepcopy_VkImageSubresourceRange(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSubresourceRange* from,
VkImageSubresourceRange* to);
void deepcopy_VkImageMemoryBarrier(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageMemoryBarrier* from,
VkImageMemoryBarrier* to);
void deepcopy_VkMemoryBarrier(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryBarrier* from,
VkMemoryBarrier* to);
void deepcopy_VkAllocationCallbacks(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAllocationCallbacks* from,
VkAllocationCallbacks* to);
void deepcopy_VkApplicationInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkApplicationInfo* from,
VkApplicationInfo* to);
void deepcopy_VkFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFormatProperties* from,
VkFormatProperties* to);
void deepcopy_VkImageFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageFormatProperties* from,
VkImageFormatProperties* to);
void deepcopy_VkInstanceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkInstanceCreateInfo* from,
VkInstanceCreateInfo* to);
void deepcopy_VkMemoryHeap(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryHeap* from,
VkMemoryHeap* to);
void deepcopy_VkMemoryType(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryType* from,
VkMemoryType* to);
void deepcopy_VkPhysicalDeviceFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures* from,
VkPhysicalDeviceFeatures* to);
void deepcopy_VkPhysicalDeviceLimits(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceLimits* from,
VkPhysicalDeviceLimits* to);
void deepcopy_VkPhysicalDeviceMemoryProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties* from,
VkPhysicalDeviceMemoryProperties* to);
void deepcopy_VkPhysicalDeviceSparseProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseProperties* from,
VkPhysicalDeviceSparseProperties* to);
void deepcopy_VkPhysicalDeviceProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceProperties* from,
VkPhysicalDeviceProperties* to);
void deepcopy_VkQueueFamilyProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueueFamilyProperties* from,
VkQueueFamilyProperties* to);
void deepcopy_VkDeviceQueueCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceQueueCreateInfo* from,
VkDeviceQueueCreateInfo* to);
void deepcopy_VkDeviceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceCreateInfo* from,
VkDeviceCreateInfo* to);
void deepcopy_VkExtensionProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExtensionProperties* from,
VkExtensionProperties* to);
void deepcopy_VkLayerProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkLayerProperties* from,
VkLayerProperties* to);
void deepcopy_VkSubmitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubmitInfo* from,
VkSubmitInfo* to);
void deepcopy_VkMappedMemoryRange(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMappedMemoryRange* from,
VkMappedMemoryRange* to);
void deepcopy_VkMemoryAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryAllocateInfo* from,
VkMemoryAllocateInfo* to);
void deepcopy_VkMemoryRequirements(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryRequirements* from,
VkMemoryRequirements* to);
void deepcopy_VkSparseMemoryBind(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseMemoryBind* from,
VkSparseMemoryBind* to);
void deepcopy_VkSparseBufferMemoryBindInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseBufferMemoryBindInfo* from,
VkSparseBufferMemoryBindInfo* to);
void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageOpaqueMemoryBindInfo* from,
VkSparseImageOpaqueMemoryBindInfo* to);
void deepcopy_VkImageSubresource(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSubresource* from,
VkImageSubresource* to);
void deepcopy_VkSparseImageMemoryBind(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageMemoryBind* from,
VkSparseImageMemoryBind* to);
void deepcopy_VkSparseImageMemoryBindInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageMemoryBindInfo* from,
VkSparseImageMemoryBindInfo* to);
void deepcopy_VkBindSparseInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindSparseInfo* from,
VkBindSparseInfo* to);
void deepcopy_VkSparseImageFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageFormatProperties* from,
VkSparseImageFormatProperties* to);
void deepcopy_VkSparseImageMemoryRequirements(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements* from,
VkSparseImageMemoryRequirements* to);
void deepcopy_VkFenceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFenceCreateInfo* from,
VkFenceCreateInfo* to);
void deepcopy_VkSemaphoreCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreCreateInfo* from,
VkSemaphoreCreateInfo* to);
void deepcopy_VkEventCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkEventCreateInfo* from,
VkEventCreateInfo* to);
void deepcopy_VkQueryPoolCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueryPoolCreateInfo* from,
VkQueryPoolCreateInfo* to);
void deepcopy_VkBufferCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferCreateInfo* from,
VkBufferCreateInfo* to);
void deepcopy_VkBufferViewCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferViewCreateInfo* from,
VkBufferViewCreateInfo* to);
void deepcopy_VkImageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageCreateInfo* from,
VkImageCreateInfo* to);
void deepcopy_VkSubresourceLayout(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubresourceLayout* from,
VkSubresourceLayout* to);
void deepcopy_VkComponentMapping(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkComponentMapping* from,
VkComponentMapping* to);
void deepcopy_VkImageViewCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewCreateInfo* from,
VkImageViewCreateInfo* to);
void deepcopy_VkShaderModuleCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShaderModuleCreateInfo* from,
VkShaderModuleCreateInfo* to);
void deepcopy_VkPipelineCacheCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCacheCreateInfo* from,
VkPipelineCacheCreateInfo* to);
void deepcopy_VkSpecializationMapEntry(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSpecializationMapEntry* from,
VkSpecializationMapEntry* to);
void deepcopy_VkSpecializationInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSpecializationInfo* from,
VkSpecializationInfo* to);
void deepcopy_VkPipelineShaderStageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineShaderStageCreateInfo* from,
VkPipelineShaderStageCreateInfo* to);
void deepcopy_VkComputePipelineCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkComputePipelineCreateInfo* from,
VkComputePipelineCreateInfo* to);
void deepcopy_VkVertexInputBindingDescription(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkVertexInputBindingDescription* from,
VkVertexInputBindingDescription* to);
void deepcopy_VkVertexInputAttributeDescription(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkVertexInputAttributeDescription* from,
VkVertexInputAttributeDescription* to);
void deepcopy_VkPipelineVertexInputStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineVertexInputStateCreateInfo* from,
VkPipelineVertexInputStateCreateInfo* to);
void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineInputAssemblyStateCreateInfo* from,
VkPipelineInputAssemblyStateCreateInfo* to);
void deepcopy_VkPipelineTessellationStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineTessellationStateCreateInfo* from,
VkPipelineTessellationStateCreateInfo* to);
void deepcopy_VkViewport(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkViewport* from,
VkViewport* to);
void deepcopy_VkPipelineViewportStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportStateCreateInfo* from,
VkPipelineViewportStateCreateInfo* to);
void deepcopy_VkPipelineRasterizationStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationStateCreateInfo* from,
VkPipelineRasterizationStateCreateInfo* to);
void deepcopy_VkPipelineMultisampleStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineMultisampleStateCreateInfo* from,
VkPipelineMultisampleStateCreateInfo* to);
void deepcopy_VkStencilOpState(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkStencilOpState* from,
VkStencilOpState* to);
void deepcopy_VkPipelineDepthStencilStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineDepthStencilStateCreateInfo* from,
VkPipelineDepthStencilStateCreateInfo* to);
void deepcopy_VkPipelineColorBlendAttachmentState(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineColorBlendAttachmentState* from,
VkPipelineColorBlendAttachmentState* to);
void deepcopy_VkPipelineColorBlendStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineColorBlendStateCreateInfo* from,
VkPipelineColorBlendStateCreateInfo* to);
void deepcopy_VkPipelineDynamicStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineDynamicStateCreateInfo* from,
VkPipelineDynamicStateCreateInfo* to);
void deepcopy_VkGraphicsPipelineCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGraphicsPipelineCreateInfo* from,
VkGraphicsPipelineCreateInfo* to);
void deepcopy_VkPushConstantRange(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPushConstantRange* from,
VkPushConstantRange* to);
void deepcopy_VkPipelineLayoutCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineLayoutCreateInfo* from,
VkPipelineLayoutCreateInfo* to);
void deepcopy_VkSamplerCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerCreateInfo* from,
VkSamplerCreateInfo* to);
void deepcopy_VkCopyDescriptorSet(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyDescriptorSet* from,
VkCopyDescriptorSet* to);
void deepcopy_VkDescriptorBufferInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorBufferInfo* from,
VkDescriptorBufferInfo* to);
void deepcopy_VkDescriptorImageInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorImageInfo* from,
VkDescriptorImageInfo* to);
void deepcopy_VkDescriptorPoolSize(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorPoolSize* from,
VkDescriptorPoolSize* to);
void deepcopy_VkDescriptorPoolCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorPoolCreateInfo* from,
VkDescriptorPoolCreateInfo* to);
void deepcopy_VkDescriptorSetAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetAllocateInfo* from,
VkDescriptorSetAllocateInfo* to);
void deepcopy_VkDescriptorSetLayoutBinding(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBinding* from,
VkDescriptorSetLayoutBinding* to);
void deepcopy_VkDescriptorSetLayoutCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetLayoutCreateInfo* from,
VkDescriptorSetLayoutCreateInfo* to);
void deepcopy_VkWriteDescriptorSet(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWriteDescriptorSet* from,
VkWriteDescriptorSet* to);
void deepcopy_VkAttachmentDescription(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentDescription* from,
VkAttachmentDescription* to);
void deepcopy_VkAttachmentReference(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentReference* from,
VkAttachmentReference* to);
void deepcopy_VkFramebufferCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFramebufferCreateInfo* from,
VkFramebufferCreateInfo* to);
void deepcopy_VkSubpassDescription(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDescription* from,
VkSubpassDescription* to);
void deepcopy_VkSubpassDependency(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDependency* from,
VkSubpassDependency* to);
void deepcopy_VkRenderPassCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassCreateInfo* from,
VkRenderPassCreateInfo* to);
void deepcopy_VkCommandPoolCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandPoolCreateInfo* from,
VkCommandPoolCreateInfo* to);
void deepcopy_VkCommandBufferAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferAllocateInfo* from,
VkCommandBufferAllocateInfo* to);
void deepcopy_VkCommandBufferInheritanceInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferInheritanceInfo* from,
VkCommandBufferInheritanceInfo* to);
void deepcopy_VkCommandBufferBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferBeginInfo* from,
VkCommandBufferBeginInfo* to);
void deepcopy_VkBufferCopy(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferCopy* from,
VkBufferCopy* to);
void deepcopy_VkImageSubresourceLayers(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSubresourceLayers* from,
VkImageSubresourceLayers* to);
void deepcopy_VkBufferImageCopy(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferImageCopy* from,
VkBufferImageCopy* to);
void deepcopy_VkClearColorValue(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearColorValue* from,
VkClearColorValue* to);
void deepcopy_VkClearDepthStencilValue(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearDepthStencilValue* from,
VkClearDepthStencilValue* to);
void deepcopy_VkClearValue(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearValue* from,
VkClearValue* to);
void deepcopy_VkClearAttachment(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearAttachment* from,
VkClearAttachment* to);
void deepcopy_VkClearRect(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkClearRect* from,
VkClearRect* to);
void deepcopy_VkImageBlit(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageBlit* from,
VkImageBlit* to);
void deepcopy_VkImageCopy(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageCopy* from,
VkImageCopy* to);
void deepcopy_VkImageResolve(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageResolve* from,
VkImageResolve* to);
void deepcopy_VkRenderPassBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassBeginInfo* from,
VkRenderPassBeginInfo* to);
#endif
#ifdef VK_VERSION_1_1
void deepcopy_VkPhysicalDeviceSubgroupProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupProperties* from,
VkPhysicalDeviceSubgroupProperties* to);
void deepcopy_VkBindBufferMemoryInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindBufferMemoryInfo* from,
VkBindBufferMemoryInfo* to);
void deepcopy_VkBindImageMemoryInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindImageMemoryInfo* from,
VkBindImageMemoryInfo* to);
void deepcopy_VkPhysicalDevice16BitStorageFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevice16BitStorageFeatures* from,
VkPhysicalDevice16BitStorageFeatures* to);
void deepcopy_VkMemoryDedicatedRequirements(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryDedicatedRequirements* from,
VkMemoryDedicatedRequirements* to);
void deepcopy_VkMemoryDedicatedAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryDedicatedAllocateInfo* from,
VkMemoryDedicatedAllocateInfo* to);
void deepcopy_VkMemoryAllocateFlagsInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryAllocateFlagsInfo* from,
VkMemoryAllocateFlagsInfo* to);
void deepcopy_VkDeviceGroupRenderPassBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupRenderPassBeginInfo* from,
VkDeviceGroupRenderPassBeginInfo* to);
void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupCommandBufferBeginInfo* from,
VkDeviceGroupCommandBufferBeginInfo* to);
void deepcopy_VkDeviceGroupSubmitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupSubmitInfo* from,
VkDeviceGroupSubmitInfo* to);
void deepcopy_VkDeviceGroupBindSparseInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupBindSparseInfo* from,
VkDeviceGroupBindSparseInfo* to);
void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindBufferMemoryDeviceGroupInfo* from,
VkBindBufferMemoryDeviceGroupInfo* to);
void deepcopy_VkBindImageMemoryDeviceGroupInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindImageMemoryDeviceGroupInfo* from,
VkBindImageMemoryDeviceGroupInfo* to);
void deepcopy_VkPhysicalDeviceGroupProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceGroupProperties* from,
VkPhysicalDeviceGroupProperties* to);
void deepcopy_VkDeviceGroupDeviceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupDeviceCreateInfo* from,
VkDeviceGroupDeviceCreateInfo* to);
void deepcopy_VkBufferMemoryRequirementsInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferMemoryRequirementsInfo2* from,
VkBufferMemoryRequirementsInfo2* to);
void deepcopy_VkImageMemoryRequirementsInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageMemoryRequirementsInfo2* from,
VkImageMemoryRequirementsInfo2* to);
void deepcopy_VkImageSparseMemoryRequirementsInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSparseMemoryRequirementsInfo2* from,
VkImageSparseMemoryRequirementsInfo2* to);
void deepcopy_VkMemoryRequirements2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryRequirements2* from,
VkMemoryRequirements2* to);
void deepcopy_VkSparseImageMemoryRequirements2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements2* from,
VkSparseImageMemoryRequirements2* to);
void deepcopy_VkPhysicalDeviceFeatures2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures2* from,
VkPhysicalDeviceFeatures2* to);
void deepcopy_VkPhysicalDeviceProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceProperties2* from,
VkPhysicalDeviceProperties2* to);
void deepcopy_VkFormatProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFormatProperties2* from,
VkFormatProperties2* to);
void deepcopy_VkImageFormatProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageFormatProperties2* from,
VkImageFormatProperties2* to);
void deepcopy_VkPhysicalDeviceImageFormatInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImageFormatInfo2* from,
VkPhysicalDeviceImageFormatInfo2* to);
void deepcopy_VkQueueFamilyProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueueFamilyProperties2* from,
VkQueueFamilyProperties2* to);
void deepcopy_VkPhysicalDeviceMemoryProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties2* from,
VkPhysicalDeviceMemoryProperties2* to);
void deepcopy_VkSparseImageFormatProperties2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSparseImageFormatProperties2* from,
VkSparseImageFormatProperties2* to);
void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseImageFormatInfo2* from,
VkPhysicalDeviceSparseImageFormatInfo2* to);
void deepcopy_VkPhysicalDevicePointClippingProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePointClippingProperties* from,
VkPhysicalDevicePointClippingProperties* to);
void deepcopy_VkInputAttachmentAspectReference(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkInputAttachmentAspectReference* from,
VkInputAttachmentAspectReference* to);
void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* from,
VkRenderPassInputAttachmentAspectCreateInfo* to);
void deepcopy_VkImageViewUsageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewUsageCreateInfo* from,
VkImageViewUsageCreateInfo* to);
void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* from,
VkPipelineTessellationDomainOriginStateCreateInfo* to);
void deepcopy_VkRenderPassMultiviewCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassMultiviewCreateInfo* from,
VkRenderPassMultiviewCreateInfo* to);
void deepcopy_VkPhysicalDeviceMultiviewFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewFeatures* from,
VkPhysicalDeviceMultiviewFeatures* to);
void deepcopy_VkPhysicalDeviceMultiviewProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewProperties* from,
VkPhysicalDeviceMultiviewProperties* to);
void deepcopy_VkPhysicalDeviceVariablePointersFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* from,
VkPhysicalDeviceVariablePointersFeatures* to);
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures, deepcopy_VkPhysicalDeviceVariablePointerFeatures);
void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryFeatures* from,
VkPhysicalDeviceProtectedMemoryFeatures* to);
void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* from,
VkPhysicalDeviceProtectedMemoryProperties* to);
void deepcopy_VkDeviceQueueInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceQueueInfo2* from,
VkDeviceQueueInfo2* to);
void deepcopy_VkProtectedSubmitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkProtectedSubmitInfo* from,
VkProtectedSubmitInfo* to);
void deepcopy_VkSamplerYcbcrConversionCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionCreateInfo* from,
VkSamplerYcbcrConversionCreateInfo* to);
void deepcopy_VkSamplerYcbcrConversionInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionInfo* from,
VkSamplerYcbcrConversionInfo* to);
void deepcopy_VkBindImagePlaneMemoryInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindImagePlaneMemoryInfo* from,
VkBindImagePlaneMemoryInfo* to);
void deepcopy_VkImagePlaneMemoryRequirementsInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImagePlaneMemoryRequirementsInfo* from,
VkImagePlaneMemoryRequirementsInfo* to);
void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
VkPhysicalDeviceSamplerYcbcrConversionFeatures* to);
void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* from,
VkSamplerYcbcrConversionImageFormatProperties* to);
void deepcopy_VkDescriptorUpdateTemplateEntry(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateEntry* from,
VkDescriptorUpdateTemplateEntry* to);
void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateCreateInfo* from,
VkDescriptorUpdateTemplateCreateInfo* to);
void deepcopy_VkExternalMemoryProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalMemoryProperties* from,
VkExternalMemoryProperties* to);
void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalImageFormatInfo* from,
VkPhysicalDeviceExternalImageFormatInfo* to);
void deepcopy_VkExternalImageFormatProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalImageFormatProperties* from,
VkExternalImageFormatProperties* to);
void deepcopy_VkPhysicalDeviceExternalBufferInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalBufferInfo* from,
VkPhysicalDeviceExternalBufferInfo* to);
void deepcopy_VkExternalBufferProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalBufferProperties* from,
VkExternalBufferProperties* to);
void deepcopy_VkPhysicalDeviceIDProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceIDProperties* from,
VkPhysicalDeviceIDProperties* to);
void deepcopy_VkExternalMemoryImageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfo* from,
VkExternalMemoryImageCreateInfo* to);
void deepcopy_VkExternalMemoryBufferCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalMemoryBufferCreateInfo* from,
VkExternalMemoryBufferCreateInfo* to);
void deepcopy_VkExportMemoryAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfo* from,
VkExportMemoryAllocateInfo* to);
void deepcopy_VkPhysicalDeviceExternalFenceInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalFenceInfo* from,
VkPhysicalDeviceExternalFenceInfo* to);
void deepcopy_VkExternalFenceProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalFenceProperties* from,
VkExternalFenceProperties* to);
void deepcopy_VkExportFenceCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportFenceCreateInfo* from,
VkExportFenceCreateInfo* to);
void deepcopy_VkExportSemaphoreCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportSemaphoreCreateInfo* from,
VkExportSemaphoreCreateInfo* to);
void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalSemaphoreInfo* from,
VkPhysicalDeviceExternalSemaphoreInfo* to);
void deepcopy_VkExternalSemaphoreProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalSemaphoreProperties* from,
VkExternalSemaphoreProperties* to);
void deepcopy_VkPhysicalDeviceMaintenance3Properties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMaintenance3Properties* from,
VkPhysicalDeviceMaintenance3Properties* to);
void deepcopy_VkDescriptorSetLayoutSupport(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetLayoutSupport* from,
VkDescriptorSetLayoutSupport* to);
void deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* from,
VkPhysicalDeviceShaderDrawParametersFeatures* to);
@@ -937,390 +1115,464 @@
#endif
#ifdef VK_VERSION_1_2
void deepcopy_VkPhysicalDeviceVulkan11Features(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Features* from,
VkPhysicalDeviceVulkan11Features* to);
void deepcopy_VkPhysicalDeviceVulkan11Properties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Properties* from,
VkPhysicalDeviceVulkan11Properties* to);
void deepcopy_VkPhysicalDeviceVulkan12Features(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Features* from,
VkPhysicalDeviceVulkan12Features* to);
void deepcopy_VkConformanceVersion(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkConformanceVersion* from,
VkConformanceVersion* to);
void deepcopy_VkPhysicalDeviceVulkan12Properties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Properties* from,
VkPhysicalDeviceVulkan12Properties* to);
void deepcopy_VkImageFormatListCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageFormatListCreateInfo* from,
VkImageFormatListCreateInfo* to);
void deepcopy_VkAttachmentDescription2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentDescription2* from,
VkAttachmentDescription2* to);
void deepcopy_VkAttachmentReference2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentReference2* from,
VkAttachmentReference2* to);
void deepcopy_VkSubpassDescription2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDescription2* from,
VkSubpassDescription2* to);
void deepcopy_VkSubpassDependency2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDependency2* from,
VkSubpassDependency2* to);
void deepcopy_VkRenderPassCreateInfo2(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassCreateInfo2* from,
VkRenderPassCreateInfo2* to);
void deepcopy_VkSubpassBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassBeginInfo* from,
VkSubpassBeginInfo* to);
void deepcopy_VkSubpassEndInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassEndInfo* from,
VkSubpassEndInfo* to);
void deepcopy_VkPhysicalDevice8BitStorageFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevice8BitStorageFeatures* from,
VkPhysicalDevice8BitStorageFeatures* to);
void deepcopy_VkPhysicalDeviceDriverProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDriverProperties* from,
VkPhysicalDeviceDriverProperties* to);
void deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicInt64Features* from,
VkPhysicalDeviceShaderAtomicInt64Features* to);
void deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* from,
VkPhysicalDeviceShaderFloat16Int8Features* to);
void deepcopy_VkPhysicalDeviceFloatControlsProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFloatControlsProperties* from,
VkPhysicalDeviceFloatControlsProperties* to);
void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* from,
VkDescriptorSetLayoutBindingFlagsCreateInfo* to);
void deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* from,
VkPhysicalDeviceDescriptorIndexingFeatures* to);
void deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* from,
VkPhysicalDeviceDescriptorIndexingProperties* to);
void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* from,
VkDescriptorSetVariableDescriptorCountAllocateInfo* to);
void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* from,
VkDescriptorSetVariableDescriptorCountLayoutSupport* to);
void deepcopy_VkSubpassDescriptionDepthStencilResolve(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassDescriptionDepthStencilResolve* from,
VkSubpassDescriptionDepthStencilResolve* to);
void deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* from,
VkPhysicalDeviceDepthStencilResolveProperties* to);
void deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* from,
VkPhysicalDeviceScalarBlockLayoutFeatures* to);
void deepcopy_VkImageStencilUsageCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageStencilUsageCreateInfo* from,
VkImageStencilUsageCreateInfo* to);
void deepcopy_VkSamplerReductionModeCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerReductionModeCreateInfo* from,
VkSamplerReductionModeCreateInfo* to);
void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* from,
VkPhysicalDeviceSamplerFilterMinmaxProperties* to);
void deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* from,
VkPhysicalDeviceVulkanMemoryModelFeatures* to);
void deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* from,
VkPhysicalDeviceImagelessFramebufferFeatures* to);
void deepcopy_VkFramebufferAttachmentImageInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFramebufferAttachmentImageInfo* from,
VkFramebufferAttachmentImageInfo* to);
void deepcopy_VkFramebufferAttachmentsCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFramebufferAttachmentsCreateInfo* from,
VkFramebufferAttachmentsCreateInfo* to);
void deepcopy_VkRenderPassAttachmentBeginInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassAttachmentBeginInfo* from,
VkRenderPassAttachmentBeginInfo* to);
void deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* from,
VkPhysicalDeviceUniformBufferStandardLayoutFeatures* to);
void deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* from,
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* to);
void deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* from,
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* to);
void deepcopy_VkAttachmentReferenceStencilLayout(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentReferenceStencilLayout* from,
VkAttachmentReferenceStencilLayout* to);
void deepcopy_VkAttachmentDescriptionStencilLayout(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentDescriptionStencilLayout* from,
VkAttachmentDescriptionStencilLayout* to);
void deepcopy_VkPhysicalDeviceHostQueryResetFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceHostQueryResetFeatures* from,
VkPhysicalDeviceHostQueryResetFeatures* to);
void deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* from,
VkPhysicalDeviceTimelineSemaphoreFeatures* to);
void deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* from,
VkPhysicalDeviceTimelineSemaphoreProperties* to);
void deepcopy_VkSemaphoreTypeCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreTypeCreateInfo* from,
VkSemaphoreTypeCreateInfo* to);
void deepcopy_VkTimelineSemaphoreSubmitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkTimelineSemaphoreSubmitInfo* from,
VkTimelineSemaphoreSubmitInfo* to);
void deepcopy_VkSemaphoreWaitInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreWaitInfo* from,
VkSemaphoreWaitInfo* to);
void deepcopy_VkSemaphoreSignalInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreSignalInfo* from,
VkSemaphoreSignalInfo* to);
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* from,
VkPhysicalDeviceBufferDeviceAddressFeatures* to);
void deepcopy_VkBufferDeviceAddressInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferDeviceAddressInfo* from,
VkBufferDeviceAddressInfo* to);
void deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferOpaqueCaptureAddressCreateInfo* from,
VkBufferOpaqueCaptureAddressCreateInfo* to);
void deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* from,
VkMemoryOpaqueCaptureAddressAllocateInfo* to);
void deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* from,
VkDeviceMemoryOpaqueCaptureAddressInfo* to);
#endif
#ifdef VK_KHR_surface
void deepcopy_VkSurfaceCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesKHR* from,
VkSurfaceCapabilitiesKHR* to);
void deepcopy_VkSurfaceFormatKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceFormatKHR* from,
VkSurfaceFormatKHR* to);
#endif
#ifdef VK_KHR_swapchain
void deepcopy_VkSwapchainCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSwapchainCreateInfoKHR* from,
VkSwapchainCreateInfoKHR* to);
void deepcopy_VkPresentInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentInfoKHR* from,
VkPresentInfoKHR* to);
void deepcopy_VkImageSwapchainCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageSwapchainCreateInfoKHR* from,
VkImageSwapchainCreateInfoKHR* to);
void deepcopy_VkBindImageMemorySwapchainInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindImageMemorySwapchainInfoKHR* from,
VkBindImageMemorySwapchainInfoKHR* to);
void deepcopy_VkAcquireNextImageInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAcquireNextImageInfoKHR* from,
VkAcquireNextImageInfoKHR* to);
void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupPresentCapabilitiesKHR* from,
VkDeviceGroupPresentCapabilitiesKHR* to);
void deepcopy_VkDeviceGroupPresentInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupPresentInfoKHR* from,
VkDeviceGroupPresentInfoKHR* to);
void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceGroupSwapchainCreateInfoKHR* from,
VkDeviceGroupSwapchainCreateInfoKHR* to);
#endif
#ifdef VK_KHR_display
void deepcopy_VkDisplayModeParametersKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayModeParametersKHR* from,
VkDisplayModeParametersKHR* to);
void deepcopy_VkDisplayModeCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayModeCreateInfoKHR* from,
VkDisplayModeCreateInfoKHR* to);
void deepcopy_VkDisplayModePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayModePropertiesKHR* from,
VkDisplayModePropertiesKHR* to);
void deepcopy_VkDisplayPlaneCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilitiesKHR* from,
VkDisplayPlaneCapabilitiesKHR* to);
void deepcopy_VkDisplayPlanePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlanePropertiesKHR* from,
VkDisplayPlanePropertiesKHR* to);
void deepcopy_VkDisplayPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPropertiesKHR* from,
VkDisplayPropertiesKHR* to);
void deepcopy_VkDisplaySurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplaySurfaceCreateInfoKHR* from,
VkDisplaySurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_display_swapchain
void deepcopy_VkDisplayPresentInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPresentInfoKHR* from,
VkDisplayPresentInfoKHR* to);
#endif
#ifdef VK_KHR_xlib_surface
void deepcopy_VkXlibSurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkXlibSurfaceCreateInfoKHR* from,
VkXlibSurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_xcb_surface
void deepcopy_VkXcbSurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkXcbSurfaceCreateInfoKHR* from,
VkXcbSurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_wayland_surface
void deepcopy_VkWaylandSurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWaylandSurfaceCreateInfoKHR* from,
VkWaylandSurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_android_surface
void deepcopy_VkAndroidSurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAndroidSurfaceCreateInfoKHR* from,
VkAndroidSurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_win32_surface
void deepcopy_VkWin32SurfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWin32SurfaceCreateInfoKHR* from,
VkWin32SurfaceCreateInfoKHR* to);
@@ -1405,46 +1657,54 @@
#endif
#ifdef VK_KHR_external_memory_win32
void deepcopy_VkImportMemoryWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoKHR* from,
VkImportMemoryWin32HandleInfoKHR* to);
void deepcopy_VkExportMemoryWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoKHR* from,
VkExportMemoryWin32HandleInfoKHR* to);
void deepcopy_VkMemoryWin32HandlePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryWin32HandlePropertiesKHR* from,
VkMemoryWin32HandlePropertiesKHR* to);
void deepcopy_VkMemoryGetWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryGetWin32HandleInfoKHR* from,
VkMemoryGetWin32HandleInfoKHR* to);
#endif
#ifdef VK_KHR_external_memory_fd
void deepcopy_VkImportMemoryFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportMemoryFdInfoKHR* from,
VkImportMemoryFdInfoKHR* to);
void deepcopy_VkMemoryFdPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryFdPropertiesKHR* from,
VkMemoryFdPropertiesKHR* to);
void deepcopy_VkMemoryGetFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryGetFdInfoKHR* from,
VkMemoryGetFdInfoKHR* to);
#endif
#ifdef VK_KHR_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
VkWin32KeyedMutexAcquireReleaseInfoKHR* to);
@@ -1461,41 +1721,48 @@
#endif
#ifdef VK_KHR_external_semaphore_win32
void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportSemaphoreWin32HandleInfoKHR* from,
VkImportSemaphoreWin32HandleInfoKHR* to);
void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportSemaphoreWin32HandleInfoKHR* from,
VkExportSemaphoreWin32HandleInfoKHR* to);
void deepcopy_VkD3D12FenceSubmitInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkD3D12FenceSubmitInfoKHR* from,
VkD3D12FenceSubmitInfoKHR* to);
void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreGetWin32HandleInfoKHR* from,
VkSemaphoreGetWin32HandleInfoKHR* to);
#endif
#ifdef VK_KHR_external_semaphore_fd
void deepcopy_VkImportSemaphoreFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportSemaphoreFdInfoKHR* from,
VkImportSemaphoreFdInfoKHR* to);
void deepcopy_VkSemaphoreGetFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSemaphoreGetFdInfoKHR* from,
VkSemaphoreGetFdInfoKHR* to);
#endif
#ifdef VK_KHR_push_descriptor
void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
VkPhysicalDevicePushDescriptorPropertiesKHR* to);
@@ -1512,17 +1779,20 @@
#endif
#ifdef VK_KHR_incremental_present
void deepcopy_VkRectLayerKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRectLayerKHR* from,
VkRectLayerKHR* to);
void deepcopy_VkPresentRegionKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentRegionKHR* from,
VkPresentRegionKHR* to);
void deepcopy_VkPresentRegionsKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentRegionsKHR* from,
VkPresentRegionsKHR* to);
@@ -1561,7 +1831,8 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* from,
VkSharedPresentSurfaceCapabilitiesKHR* to);
@@ -1578,71 +1849,84 @@
#endif
#ifdef VK_KHR_external_fence_win32
void deepcopy_VkImportFenceWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportFenceWin32HandleInfoKHR* from,
VkImportFenceWin32HandleInfoKHR* to);
void deepcopy_VkExportFenceWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportFenceWin32HandleInfoKHR* from,
VkExportFenceWin32HandleInfoKHR* to);
void deepcopy_VkFenceGetWin32HandleInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFenceGetWin32HandleInfoKHR* from,
VkFenceGetWin32HandleInfoKHR* to);
#endif
#ifdef VK_KHR_external_fence_fd
void deepcopy_VkImportFenceFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportFenceFdInfoKHR* from,
VkImportFenceFdInfoKHR* to);
void deepcopy_VkFenceGetFdInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFenceGetFdInfoKHR* from,
VkFenceGetFdInfoKHR* to);
#endif
#ifdef VK_KHR_performance_query
void deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* from,
VkPhysicalDevicePerformanceQueryFeaturesKHR* to);
void deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* from,
VkPhysicalDevicePerformanceQueryPropertiesKHR* to);
void deepcopy_VkPerformanceCounterKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceCounterKHR* from,
VkPerformanceCounterKHR* to);
void deepcopy_VkPerformanceCounterDescriptionKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceCounterDescriptionKHR* from,
VkPerformanceCounterDescriptionKHR* to);
void deepcopy_VkQueryPoolPerformanceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueryPoolPerformanceCreateInfoKHR* from,
VkQueryPoolPerformanceCreateInfoKHR* to);
void deepcopy_VkPerformanceCounterResultKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceCounterResultKHR* from,
VkPerformanceCounterResultKHR* to);
void deepcopy_VkAcquireProfilingLockInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAcquireProfilingLockInfoKHR* from,
VkAcquireProfilingLockInfoKHR* to);
void deepcopy_VkPerformanceQuerySubmitInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceQuerySubmitInfoKHR* from,
VkPerformanceQuerySubmitInfoKHR* to);
@@ -1661,17 +1945,20 @@
#endif
#ifdef VK_KHR_get_surface_capabilities2
void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSurfaceInfo2KHR* from,
VkPhysicalDeviceSurfaceInfo2KHR* to);
void deepcopy_VkSurfaceCapabilities2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceCapabilities2KHR* from,
VkSurfaceCapabilities2KHR* to);
void deepcopy_VkSurfaceFormat2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceFormat2KHR* from,
VkSurfaceFormat2KHR* to);
@@ -1684,27 +1971,32 @@
#endif
#ifdef VK_KHR_get_display_properties2
void deepcopy_VkDisplayProperties2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayProperties2KHR* from,
VkDisplayProperties2KHR* to);
void deepcopy_VkDisplayPlaneProperties2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlaneProperties2KHR* from,
VkDisplayPlaneProperties2KHR* to);
void deepcopy_VkDisplayModeProperties2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayModeProperties2KHR* from,
VkDisplayModeProperties2KHR* to);
void deepcopy_VkDisplayPlaneInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlaneInfo2KHR* from,
VkDisplayPlaneInfo2KHR* to);
void deepcopy_VkDisplayPlaneCapabilities2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilities2KHR* from,
VkDisplayPlaneCapabilities2KHR* to);
@@ -1757,12 +2049,14 @@
#endif
#ifdef VK_KHR_portability_subset
void deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* from,
VkPhysicalDevicePortabilitySubsetFeaturesKHR* to);
void deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* from,
VkPhysicalDevicePortabilitySubsetPropertiesKHR* to);
@@ -1789,7 +2083,8 @@
#endif
#ifdef VK_KHR_shader_clock
void deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* from,
VkPhysicalDeviceShaderClockFeaturesKHR* to);
@@ -1832,34 +2127,40 @@
#endif
#ifdef VK_KHR_shader_terminate_invocation
void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* from,
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* to);
#endif
#ifdef VK_KHR_fragment_shading_rate
void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFragmentShadingRateAttachmentInfoKHR* from,
VkFragmentShadingRateAttachmentInfoKHR* to);
void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* from,
VkPipelineFragmentShadingRateStateCreateInfoKHR* to);
void deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* from,
VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to);
void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* from,
VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to);
void deepcopy_VkPhysicalDeviceFragmentShadingRateKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* from,
VkPhysicalDeviceFragmentShadingRateKHR* to);
@@ -1868,7 +2169,8 @@
#endif
#ifdef VK_KHR_surface_protected_capabilities
void deepcopy_VkSurfaceProtectedCapabilitiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceProtectedCapabilitiesKHR* from,
VkSurfaceProtectedCapabilitiesKHR* to);
@@ -1901,44 +2203,52 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* from,
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to);
void deepcopy_VkPipelineInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineInfoKHR* from,
VkPipelineInfoKHR* to);
void deepcopy_VkPipelineExecutablePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutablePropertiesKHR* from,
VkPipelineExecutablePropertiesKHR* to);
void deepcopy_VkPipelineExecutableInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutableInfoKHR* from,
VkPipelineExecutableInfoKHR* to);
void deepcopy_VkPipelineExecutableStatisticValueKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticValueKHR* from,
VkPipelineExecutableStatisticValueKHR* to);
void deepcopy_VkPipelineExecutableStatisticKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticKHR* from,
VkPipelineExecutableStatisticKHR* to);
void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* from,
VkPipelineExecutableInternalRepresentationKHR* to);
#endif
#ifdef VK_KHR_pipeline_library
void deepcopy_VkPipelineLibraryCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineLibraryCreateInfoKHR* from,
VkPipelineLibraryCreateInfoKHR* to);
@@ -1947,71 +2257,84 @@
#endif
#ifdef VK_KHR_copy_commands2
void deepcopy_VkBufferCopy2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferCopy2KHR* from,
VkBufferCopy2KHR* to);
void deepcopy_VkCopyBufferInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyBufferInfo2KHR* from,
VkCopyBufferInfo2KHR* to);
void deepcopy_VkImageCopy2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageCopy2KHR* from,
VkImageCopy2KHR* to);
void deepcopy_VkCopyImageInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyImageInfo2KHR* from,
VkCopyImageInfo2KHR* to);
void deepcopy_VkBufferImageCopy2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferImageCopy2KHR* from,
VkBufferImageCopy2KHR* to);
void deepcopy_VkCopyBufferToImageInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyBufferToImageInfo2KHR* from,
VkCopyBufferToImageInfo2KHR* to);
void deepcopy_VkCopyImageToBufferInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyImageToBufferInfo2KHR* from,
VkCopyImageToBufferInfo2KHR* to);
void deepcopy_VkImageBlit2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageBlit2KHR* from,
VkImageBlit2KHR* to);
void deepcopy_VkBlitImageInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBlitImageInfo2KHR* from,
VkBlitImageInfo2KHR* to);
void deepcopy_VkImageResolve2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageResolve2KHR* from,
VkImageResolve2KHR* to);
void deepcopy_VkResolveImageInfo2KHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkResolveImageInfo2KHR* from,
VkResolveImageInfo2KHR* to);
#endif
#ifdef VK_ANDROID_native_buffer
void deepcopy_VkNativeBufferANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkNativeBufferANDROID* from,
VkNativeBufferANDROID* to);
#endif
#ifdef VK_EXT_debug_report
void deepcopy_VkDebugReportCallbackCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugReportCallbackCreateInfoEXT* from,
VkDebugReportCallbackCreateInfoEXT* to);
@@ -2024,7 +2347,8 @@
#endif
#ifdef VK_AMD_rasterization_order
void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* from,
VkPipelineRasterizationStateRasterizationOrderAMD* to);
@@ -2035,17 +2359,20 @@
#endif
#ifdef VK_EXT_debug_marker
void deepcopy_VkDebugMarkerObjectNameInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugMarkerObjectNameInfoEXT* from,
VkDebugMarkerObjectNameInfoEXT* to);
void deepcopy_VkDebugMarkerObjectTagInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugMarkerObjectTagInfoEXT* from,
VkDebugMarkerObjectTagInfoEXT* to);
void deepcopy_VkDebugMarkerMarkerInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugMarkerMarkerInfoEXT* from,
VkDebugMarkerMarkerInfoEXT* to);
@@ -2054,46 +2381,54 @@
#endif
#ifdef VK_NV_dedicated_allocation
void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDedicatedAllocationImageCreateInfoNV* from,
VkDedicatedAllocationImageCreateInfoNV* to);
void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDedicatedAllocationBufferCreateInfoNV* from,
VkDedicatedAllocationBufferCreateInfoNV* to);
void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* from,
VkDedicatedAllocationMemoryAllocateInfoNV* to);
#endif
#ifdef VK_EXT_transform_feedback
void deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* from,
VkPhysicalDeviceTransformFeedbackFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* from,
VkPhysicalDeviceTransformFeedbackPropertiesEXT* to);
void deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* from,
VkPipelineRasterizationStateStreamCreateInfoEXT* to);
#endif
#ifdef VK_NVX_image_view_handle
void deepcopy_VkImageViewHandleInfoNVX(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewHandleInfoNVX* from,
VkImageViewHandleInfoNVX* to);
void deepcopy_VkImageViewAddressPropertiesNVX(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewAddressPropertiesNVX* from,
VkImageViewAddressPropertiesNVX* to);
@@ -2108,19 +2443,22 @@
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* from,
VkTextureLODGatherFormatPropertiesAMD* to);
#endif
#ifdef VK_AMD_shader_info
void deepcopy_VkShaderResourceUsageAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShaderResourceUsageAMD* from,
VkShaderResourceUsageAMD* to);
void deepcopy_VkShaderStatisticsInfoAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShaderStatisticsInfoAMD* from,
VkShaderStatisticsInfoAMD* to);
@@ -2129,14 +2467,16 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* from,
VkStreamDescriptorSurfaceCreateInfoGGP* to);
#endif
#ifdef VK_NV_corner_sampled_image
void deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* from,
VkPhysicalDeviceCornerSampledImageFeaturesNV* to);
@@ -2145,52 +2485,60 @@
#endif
#ifdef VK_NV_external_memory_capabilities
void deepcopy_VkExternalImageFormatPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalImageFormatPropertiesNV* from,
VkExternalImageFormatPropertiesNV* to);
#endif
#ifdef VK_NV_external_memory
void deepcopy_VkExternalMemoryImageCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfoNV* from,
VkExternalMemoryImageCreateInfoNV* to);
void deepcopy_VkExportMemoryAllocateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfoNV* from,
VkExportMemoryAllocateInfoNV* to);
#endif
#ifdef VK_NV_external_memory_win32
void deepcopy_VkImportMemoryWin32HandleInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoNV* from,
VkImportMemoryWin32HandleInfoNV* to);
void deepcopy_VkExportMemoryWin32HandleInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoNV* from,
VkExportMemoryWin32HandleInfoNV* to);
#endif
#ifdef VK_NV_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
VkWin32KeyedMutexAcquireReleaseInfoNV* to);
#endif
#ifdef VK_EXT_validation_flags
void deepcopy_VkValidationFlagsEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkValidationFlagsEXT* from,
VkValidationFlagsEXT* to);
#endif
#ifdef VK_NN_vi_surface
void deepcopy_VkViSurfaceCreateInfoNN(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkViSurfaceCreateInfoNN* from,
VkViSurfaceCreateInfoNN* to);
@@ -2201,48 +2549,56 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* from,
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* to);
#endif
#ifdef VK_EXT_astc_decode_mode
void deepcopy_VkImageViewASTCDecodeModeEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageViewASTCDecodeModeEXT* from,
VkImageViewASTCDecodeModeEXT* to);
void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
VkPhysicalDeviceASTCDecodeFeaturesEXT* to);
#endif
#ifdef VK_EXT_conditional_rendering
void deepcopy_VkConditionalRenderingBeginInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkConditionalRenderingBeginInfoEXT* from,
VkConditionalRenderingBeginInfoEXT* to);
void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
VkPhysicalDeviceConditionalRenderingFeaturesEXT* to);
void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
VkCommandBufferInheritanceConditionalRenderingInfoEXT* to);
#endif
#ifdef VK_NV_clip_space_w_scaling
void deepcopy_VkViewportWScalingNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkViewportWScalingNV* from,
VkViewportWScalingNV* to);
void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportWScalingStateCreateInfoNV* from,
VkPipelineViewportWScalingStateCreateInfoNV* to);
@@ -2253,51 +2609,60 @@
#endif
#ifdef VK_EXT_display_surface_counter
void deepcopy_VkSurfaceCapabilities2EXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceCapabilities2EXT* from,
VkSurfaceCapabilities2EXT* to);
#endif
#ifdef VK_EXT_display_control
void deepcopy_VkDisplayPowerInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayPowerInfoEXT* from,
VkDisplayPowerInfoEXT* to);
void deepcopy_VkDeviceEventInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceEventInfoEXT* from,
VkDeviceEventInfoEXT* to);
void deepcopy_VkDisplayEventInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayEventInfoEXT* from,
VkDisplayEventInfoEXT* to);
void deepcopy_VkSwapchainCounterCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSwapchainCounterCreateInfoEXT* from,
VkSwapchainCounterCreateInfoEXT* to);
#endif
#ifdef VK_GOOGLE_display_timing
void deepcopy_VkRefreshCycleDurationGOOGLE(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRefreshCycleDurationGOOGLE* from,
VkRefreshCycleDurationGOOGLE* to);
void deepcopy_VkPastPresentationTimingGOOGLE(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPastPresentationTimingGOOGLE* from,
VkPastPresentationTimingGOOGLE* to);
void deepcopy_VkPresentTimeGOOGLE(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentTimeGOOGLE* from,
VkPresentTimeGOOGLE* to);
void deepcopy_VkPresentTimesInfoGOOGLE(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentTimesInfoGOOGLE* from,
VkPresentTimesInfoGOOGLE* to);
@@ -2310,55 +2675,64 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to);
#endif
#ifdef VK_NV_viewport_swizzle
void deepcopy_VkViewportSwizzleNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkViewportSwizzleNV* from,
VkViewportSwizzleNV* to);
void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* from,
VkPipelineViewportSwizzleStateCreateInfoNV* to);
#endif
#ifdef VK_EXT_discard_rectangles
void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
VkPhysicalDeviceDiscardRectanglePropertiesEXT* to);
void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
VkPipelineDiscardRectangleStateCreateInfoEXT* to);
#endif
#ifdef VK_EXT_conservative_rasterization
void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to);
void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
VkPipelineRasterizationConservativeStateCreateInfoEXT* to);
#endif
#ifdef VK_EXT_depth_clip_enable
void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
VkPhysicalDeviceDepthClipEnableFeaturesEXT* to);
void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
VkPipelineRasterizationDepthClipStateCreateInfoEXT* to);
@@ -2367,26 +2741,30 @@
#endif
#ifdef VK_EXT_hdr_metadata
void deepcopy_VkXYColorEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkXYColorEXT* from,
VkXYColorEXT* to);
void deepcopy_VkHdrMetadataEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkHdrMetadataEXT* from,
VkHdrMetadataEXT* to);
#endif
#ifdef VK_MVK_ios_surface
void deepcopy_VkIOSSurfaceCreateInfoMVK(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkIOSSurfaceCreateInfoMVK* from,
VkIOSSurfaceCreateInfoMVK* to);
#endif
#ifdef VK_MVK_macos_surface
void deepcopy_VkMacOSSurfaceCreateInfoMVK(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMacOSSurfaceCreateInfoMVK* from,
VkMacOSSurfaceCreateInfoMVK* to);
@@ -2399,59 +2777,70 @@
#endif
#ifdef VK_EXT_debug_utils
void deepcopy_VkDebugUtilsLabelEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsLabelEXT* from,
VkDebugUtilsLabelEXT* to);
void deepcopy_VkDebugUtilsObjectNameInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsObjectNameInfoEXT* from,
VkDebugUtilsObjectNameInfoEXT* to);
void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCallbackDataEXT* from,
VkDebugUtilsMessengerCallbackDataEXT* to);
void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCreateInfoEXT* from,
VkDebugUtilsMessengerCreateInfoEXT* to);
void deepcopy_VkDebugUtilsObjectTagInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDebugUtilsObjectTagInfoEXT* from,
VkDebugUtilsObjectTagInfoEXT* to);
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void deepcopy_VkAndroidHardwareBufferUsageANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAndroidHardwareBufferUsageANDROID* from,
VkAndroidHardwareBufferUsageANDROID* to);
void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* from,
VkAndroidHardwareBufferPropertiesANDROID* to);
void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
VkAndroidHardwareBufferFormatPropertiesANDROID* to);
void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* from,
VkImportAndroidHardwareBufferInfoANDROID* to);
void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
VkMemoryGetAndroidHardwareBufferInfoANDROID* to);
void deepcopy_VkExternalFormatANDROID(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkExternalFormatANDROID* from,
VkExternalFormatANDROID* to);
@@ -2470,22 +2859,26 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* from,
VkPhysicalDeviceInlineUniformBlockFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* from,
VkPhysicalDeviceInlineUniformBlockPropertiesEXT* to);
void deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* from,
VkWriteDescriptorSetInlineUniformBlockEXT* to);
void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* from,
VkDescriptorPoolInlineUniformBlockCreateInfoEXT* to);
@@ -2494,73 +2887,86 @@
#endif
#ifdef VK_EXT_sample_locations
void deepcopy_VkSampleLocationEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSampleLocationEXT* from,
VkSampleLocationEXT* to);
void deepcopy_VkSampleLocationsInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSampleLocationsInfoEXT* from,
VkSampleLocationsInfoEXT* to);
void deepcopy_VkAttachmentSampleLocationsEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAttachmentSampleLocationsEXT* from,
VkAttachmentSampleLocationsEXT* to);
void deepcopy_VkSubpassSampleLocationsEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSubpassSampleLocationsEXT* from,
VkSubpassSampleLocationsEXT* to);
void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassSampleLocationsBeginInfoEXT* from,
VkRenderPassSampleLocationsBeginInfoEXT* to);
void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* from,
VkPipelineSampleLocationsStateCreateInfoEXT* to);
void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
VkPhysicalDeviceSampleLocationsPropertiesEXT* to);
void deepcopy_VkMultisamplePropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMultisamplePropertiesEXT* from,
VkMultisamplePropertiesEXT* to);
#endif
#ifdef VK_EXT_blend_operation_advanced
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to);
void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
VkPipelineColorBlendAdvancedStateCreateInfoEXT* to);
#endif
#ifdef VK_NV_fragment_coverage_to_color
void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* from,
VkPipelineCoverageToColorStateCreateInfoNV* to);
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* from,
VkPipelineCoverageModulationStateCreateInfoNV* to);
@@ -2569,12 +2975,14 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* from,
VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* to);
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* from,
VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* to);
@@ -2583,44 +2991,52 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
void deepcopy_VkDrmFormatModifierPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesEXT* from,
VkDrmFormatModifierPropertiesEXT* to);
void deepcopy_VkDrmFormatModifierPropertiesListEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesListEXT* from,
VkDrmFormatModifierPropertiesListEXT* to);
void deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* from,
VkPhysicalDeviceImageDrmFormatModifierInfoEXT* to);
void deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* from,
VkImageDrmFormatModifierListCreateInfoEXT* to);
void deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* from,
VkImageDrmFormatModifierExplicitCreateInfoEXT* to);
void deepcopy_VkImageDrmFormatModifierPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImageDrmFormatModifierPropertiesEXT* from,
VkImageDrmFormatModifierPropertiesEXT* to);
#endif
#ifdef VK_EXT_validation_cache
void deepcopy_VkValidationCacheCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkValidationCacheCreateInfoEXT* from,
VkValidationCacheCreateInfoEXT* to);
void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* from,
VkShaderModuleValidationCacheCreateInfoEXT* to);
@@ -2641,118 +3057,140 @@
#endif
#ifdef VK_NV_shading_rate_image
void deepcopy_VkShadingRatePaletteNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkShadingRatePaletteNV* from,
VkShadingRatePaletteNV* to);
void deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* from,
VkPipelineViewportShadingRateImageStateCreateInfoNV* to);
void deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* from,
VkPhysicalDeviceShadingRateImageFeaturesNV* to);
void deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* from,
VkPhysicalDeviceShadingRateImagePropertiesNV* to);
void deepcopy_VkCoarseSampleLocationNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCoarseSampleLocationNV* from,
VkCoarseSampleLocationNV* to);
void deepcopy_VkCoarseSampleOrderCustomNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCoarseSampleOrderCustomNV* from,
VkCoarseSampleOrderCustomNV* to);
void deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* from,
VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* to);
#endif
#ifdef VK_NV_ray_tracing
void deepcopy_VkRayTracingShaderGroupCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoNV* from,
VkRayTracingShaderGroupCreateInfoNV* to);
void deepcopy_VkRayTracingPipelineCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoNV* from,
VkRayTracingPipelineCreateInfoNV* to);
void deepcopy_VkGeometryTrianglesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeometryTrianglesNV* from,
VkGeometryTrianglesNV* to);
void deepcopy_VkGeometryAABBNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeometryAABBNV* from,
VkGeometryAABBNV* to);
void deepcopy_VkGeometryDataNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeometryDataNV* from,
VkGeometryDataNV* to);
void deepcopy_VkGeometryNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeometryNV* from,
VkGeometryNV* to);
void deepcopy_VkAccelerationStructureInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureInfoNV* from,
VkAccelerationStructureInfoNV* to);
void deepcopy_VkAccelerationStructureCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoNV* from,
VkAccelerationStructureCreateInfoNV* to);
void deepcopy_VkBindAccelerationStructureMemoryInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindAccelerationStructureMemoryInfoNV* from,
VkBindAccelerationStructureMemoryInfoNV* to);
void deepcopy_VkWriteDescriptorSetAccelerationStructureNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* from,
VkWriteDescriptorSetAccelerationStructureNV* to);
void deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* from,
VkAccelerationStructureMemoryRequirementsInfoNV* to);
void deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPropertiesNV* from,
VkPhysicalDeviceRayTracingPropertiesNV* to);
void deepcopy_VkTransformMatrixKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkTransformMatrixKHR* from,
VkTransformMatrixKHR* to);
DEFINE_ALIAS_FUNCTION(deepcopy_VkTransformMatrixKHR, deepcopy_VkTransformMatrixNV);
void deepcopy_VkAabbPositionsKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAabbPositionsKHR* from,
VkAabbPositionsKHR* to);
DEFINE_ALIAS_FUNCTION(deepcopy_VkAabbPositionsKHR, deepcopy_VkAabbPositionsNV);
void deepcopy_VkAccelerationStructureInstanceKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureInstanceKHR* from,
VkAccelerationStructureInstanceKHR* to);
@@ -2761,24 +3199,28 @@
#endif
#ifdef VK_NV_representative_fragment_test
void deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* from,
VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* to);
void deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* from,
VkPipelineRepresentativeFragmentTestStateCreateInfoNV* to);
#endif
#ifdef VK_EXT_filter_cubic
void deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* from,
VkPhysicalDeviceImageViewImageFormatInfoEXT* to);
void deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* from,
VkFilterCubicImageViewImageFormatPropertiesEXT* to);
@@ -2787,24 +3229,28 @@
#endif
#ifdef VK_EXT_global_priority
void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
VkDeviceQueueGlobalPriorityCreateInfoEXT* to);
#endif
#ifdef VK_EXT_external_memory_host
void deepcopy_VkImportMemoryHostPointerInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImportMemoryHostPointerInfoEXT* from,
VkImportMemoryHostPointerInfoEXT* to);
void deepcopy_VkMemoryHostPointerPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryHostPointerPropertiesEXT* from,
VkMemoryHostPointerPropertiesEXT* to);
void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to);
@@ -2813,69 +3259,80 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void deepcopy_VkPipelineCompilerControlCreateInfoAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* from,
VkPipelineCompilerControlCreateInfoAMD* to);
#endif
#ifdef VK_EXT_calibrated_timestamps
void deepcopy_VkCalibratedTimestampInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCalibratedTimestampInfoEXT* from,
VkCalibratedTimestampInfoEXT* to);
#endif
#ifdef VK_AMD_shader_core_properties
void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* from,
VkPhysicalDeviceShaderCorePropertiesAMD* to);
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* from,
VkDeviceMemoryOverallocationCreateInfoAMD* to);
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to);
void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* from,
VkVertexInputBindingDivisorDescriptionEXT* to);
void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
VkPipelineVertexInputDivisorStateCreateInfoEXT* to);
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* from,
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* to);
#endif
#ifdef VK_GGP_frame_token
void deepcopy_VkPresentFrameTokenGGP(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPresentFrameTokenGGP* from,
VkPresentFrameTokenGGP* to);
#endif
#ifdef VK_EXT_pipeline_creation_feedback
void deepcopy_VkPipelineCreationFeedbackEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackEXT* from,
VkPipelineCreationFeedbackEXT* to);
void deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackCreateInfoEXT* from,
VkPipelineCreationFeedbackCreateInfoEXT* to);
@@ -2884,165 +3341,192 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* from,
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* to);
#endif
#ifdef VK_NV_mesh_shader
void deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderFeaturesNV* from,
VkPhysicalDeviceMeshShaderFeaturesNV* to);
void deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderPropertiesNV* from,
VkPhysicalDeviceMeshShaderPropertiesNV* to);
void deepcopy_VkDrawMeshTasksIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDrawMeshTasksIndirectCommandNV* from,
VkDrawMeshTasksIndirectCommandNV* to);
#endif
#ifdef VK_NV_fragment_shader_barycentric
void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* from,
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* to);
#endif
#ifdef VK_NV_shader_image_footprint
void deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* from,
VkPhysicalDeviceShaderImageFootprintFeaturesNV* to);
#endif
#ifdef VK_NV_scissor_exclusive
void deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* from,
VkPipelineViewportExclusiveScissorStateCreateInfoNV* to);
void deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* from,
VkPhysicalDeviceExclusiveScissorFeaturesNV* to);
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueueFamilyCheckpointPropertiesNV* from,
VkQueueFamilyCheckpointPropertiesNV* to);
void deepcopy_VkCheckpointDataNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCheckpointDataNV* from,
VkCheckpointDataNV* to);
#endif
#ifdef VK_INTEL_shader_integer_functions2
void deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* from,
VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* to);
#endif
#ifdef VK_INTEL_performance_query
void deepcopy_VkPerformanceValueDataINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceValueDataINTEL* from,
VkPerformanceValueDataINTEL* to);
void deepcopy_VkPerformanceValueINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceValueINTEL* from,
VkPerformanceValueINTEL* to);
void deepcopy_VkInitializePerformanceApiInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkInitializePerformanceApiInfoINTEL* from,
VkInitializePerformanceApiInfoINTEL* to);
void deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* from,
VkQueryPoolPerformanceQueryCreateInfoINTEL* to);
DEFINE_ALIAS_FUNCTION(deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL, deepcopy_VkQueryPoolCreateInfoINTEL);
void deepcopy_VkPerformanceMarkerInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceMarkerInfoINTEL* from,
VkPerformanceMarkerInfoINTEL* to);
void deepcopy_VkPerformanceStreamMarkerInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceStreamMarkerInfoINTEL* from,
VkPerformanceStreamMarkerInfoINTEL* to);
void deepcopy_VkPerformanceOverrideInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceOverrideInfoINTEL* from,
VkPerformanceOverrideInfoINTEL* to);
void deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* from,
VkPerformanceConfigurationAcquireInfoINTEL* to);
#endif
#ifdef VK_EXT_pci_bus_info
void deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* from,
VkPhysicalDevicePCIBusInfoPropertiesEXT* to);
#endif
#ifdef VK_AMD_display_native_hdr
void deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* from,
VkDisplayNativeHdrSurfaceCapabilitiesAMD* to);
void deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* from,
VkSwapchainDisplayNativeHdrCreateInfoAMD* to);
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkImagePipeSurfaceCreateInfoFUCHSIA* from,
VkImagePipeSurfaceCreateInfoFUCHSIA* to);
#endif
#ifdef VK_EXT_metal_surface
void deepcopy_VkMetalSurfaceCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMetalSurfaceCreateInfoEXT* from,
VkMetalSurfaceCreateInfoEXT* to);
#endif
-#ifdef VK_GOOGLE_color_buffer
-void deepcopy_VkImportColorBufferGOOGLE(
- BumpPool* pool,
- const VkImportColorBufferGOOGLE* from,
- VkImportColorBufferGOOGLE* to);
+#ifdef VK_EXT_fragment_density_map
+void deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ Allocator* alloc,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* from,
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* to);
-void deepcopy_VkImportBufferGOOGLE(
- BumpPool* pool,
- const VkImportBufferGOOGLE* from,
- VkImportBufferGOOGLE* to);
+void deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ Allocator* alloc,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* from,
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* to);
-void deepcopy_VkImportPhysicalAddressGOOGLE(
- BumpPool* pool,
- const VkImportPhysicalAddressGOOGLE* from,
- VkImportPhysicalAddressGOOGLE* to);
+void deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ Allocator* alloc,
+ VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* from,
+ VkRenderPassFragmentDensityMapCreateInfoEXT* to);
#endif
#ifdef VK_EXT_scalar_block_layout
@@ -3055,71 +3539,82 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* from,
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* from,
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* to);
void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* from,
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* to);
#endif
#ifdef VK_AMD_shader_core_properties2
void deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* from,
VkPhysicalDeviceShaderCoreProperties2AMD* to);
#endif
#ifdef VK_AMD_device_coherent_memory
void deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* from,
VkPhysicalDeviceCoherentMemoryFeaturesAMD* to);
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* from,
VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* to);
#endif
#ifdef VK_EXT_memory_budget
void deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* from,
VkPhysicalDeviceMemoryBudgetPropertiesEXT* to);
#endif
#ifdef VK_EXT_memory_priority
void deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* from,
VkPhysicalDeviceMemoryPriorityFeaturesEXT* to);
void deepcopy_VkMemoryPriorityAllocateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkMemoryPriorityAllocateInfoEXT* from,
VkMemoryPriorityAllocateInfoEXT* to);
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* from,
VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* to);
#endif
#ifdef VK_EXT_buffer_device_address
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* from,
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* to);
@@ -3128,14 +3623,16 @@
DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferDeviceAddressInfo, deepcopy_VkBufferDeviceAddressInfoEXT);
void deepcopy_VkBufferDeviceAddressCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBufferDeviceAddressCreateInfoEXT* from,
VkBufferDeviceAddressCreateInfoEXT* to);
#endif
#ifdef VK_EXT_tooling_info
void deepcopy_VkPhysicalDeviceToolPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceToolPropertiesEXT* from,
VkPhysicalDeviceToolPropertiesEXT* to);
@@ -3146,103 +3643,120 @@
#endif
#ifdef VK_EXT_validation_features
void deepcopy_VkValidationFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkValidationFeaturesEXT* from,
VkValidationFeaturesEXT* to);
#endif
#ifdef VK_NV_cooperative_matrix
void deepcopy_VkCooperativeMatrixPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCooperativeMatrixPropertiesNV* from,
VkCooperativeMatrixPropertiesNV* to);
void deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* from,
VkPhysicalDeviceCooperativeMatrixFeaturesNV* to);
void deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* from,
VkPhysicalDeviceCooperativeMatrixPropertiesNV* to);
#endif
#ifdef VK_NV_coverage_reduction_mode
void deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* from,
VkPhysicalDeviceCoverageReductionModeFeaturesNV* to);
void deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* from,
VkPipelineCoverageReductionStateCreateInfoNV* to);
void deepcopy_VkFramebufferMixedSamplesCombinationNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* from,
VkFramebufferMixedSamplesCombinationNV* to);
#endif
#ifdef VK_EXT_fragment_shader_interlock
void deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* from,
VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* to);
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* from,
VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* to);
#endif
#ifdef VK_EXT_full_screen_exclusive
void deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveInfoEXT* from,
VkSurfaceFullScreenExclusiveInfoEXT* to);
void deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* from,
VkSurfaceCapabilitiesFullScreenExclusiveEXT* to);
void deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* from,
VkSurfaceFullScreenExclusiveWin32InfoEXT* to);
#endif
#ifdef VK_EXT_headless_surface
void deepcopy_VkHeadlessSurfaceCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkHeadlessSurfaceCreateInfoEXT* from,
VkHeadlessSurfaceCreateInfoEXT* to);
#endif
#ifdef VK_EXT_line_rasterization
void deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* from,
VkPhysicalDeviceLineRasterizationFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* from,
VkPhysicalDeviceLineRasterizationPropertiesEXT* to);
void deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* from,
VkPipelineRasterizationLineStateCreateInfoEXT* to);
#endif
#ifdef VK_EXT_shader_atomic_float
void deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* from,
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* to);
@@ -3253,158 +3767,186 @@
#endif
#ifdef VK_EXT_index_type_uint8
void deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* from,
VkPhysicalDeviceIndexTypeUint8FeaturesEXT* to);
#endif
#ifdef VK_EXT_extended_dynamic_state
void deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* from,
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* to);
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* from,
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* to);
#endif
#ifdef VK_NV_device_generated_commands
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* from,
VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* to);
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* from,
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* to);
void deepcopy_VkGraphicsShaderGroupCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGraphicsShaderGroupCreateInfoNV* from,
VkGraphicsShaderGroupCreateInfoNV* to);
void deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* from,
VkGraphicsPipelineShaderGroupsCreateInfoNV* to);
void deepcopy_VkBindShaderGroupIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindShaderGroupIndirectCommandNV* from,
VkBindShaderGroupIndirectCommandNV* to);
void deepcopy_VkBindIndexBufferIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindIndexBufferIndirectCommandNV* from,
VkBindIndexBufferIndirectCommandNV* to);
void deepcopy_VkBindVertexBufferIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkBindVertexBufferIndirectCommandNV* from,
VkBindVertexBufferIndirectCommandNV* to);
void deepcopy_VkSetStateFlagsIndirectCommandNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSetStateFlagsIndirectCommandNV* from,
VkSetStateFlagsIndirectCommandNV* to);
void deepcopy_VkIndirectCommandsStreamNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkIndirectCommandsStreamNV* from,
VkIndirectCommandsStreamNV* to);
void deepcopy_VkIndirectCommandsLayoutTokenNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutTokenNV* from,
VkIndirectCommandsLayoutTokenNV* to);
void deepcopy_VkIndirectCommandsLayoutCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutCreateInfoNV* from,
VkIndirectCommandsLayoutCreateInfoNV* to);
void deepcopy_VkGeneratedCommandsInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeneratedCommandsInfoNV* from,
VkGeneratedCommandsInfoNV* to);
void deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* from,
VkGeneratedCommandsMemoryRequirementsInfoNV* to);
#endif
#ifdef VK_EXT_texel_buffer_alignment
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* from,
VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* from,
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* to);
#endif
#ifdef VK_QCOM_render_pass_transform
void deepcopy_VkRenderPassTransformBeginInfoQCOM(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRenderPassTransformBeginInfoQCOM* from,
VkRenderPassTransformBeginInfoQCOM* to);
void deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* from,
VkCommandBufferInheritanceRenderPassTransformInfoQCOM* to);
#endif
#ifdef VK_EXT_device_memory_report
void deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* from,
VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* to);
void deepcopy_VkDeviceMemoryReportCallbackDataEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceMemoryReportCallbackDataEXT* from,
VkDeviceMemoryReportCallbackDataEXT* to);
void deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* from,
VkDeviceDeviceMemoryReportCreateInfoEXT* to);
#endif
#ifdef VK_EXT_robustness2
void deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2FeaturesEXT* from,
VkPhysicalDeviceRobustness2FeaturesEXT* to);
void deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* from,
VkPhysicalDeviceRobustness2PropertiesEXT* to);
#endif
#ifdef VK_EXT_custom_border_color
void deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkSamplerCustomBorderColorCreateInfoEXT* from,
VkSamplerCustomBorderColorCreateInfoEXT* to);
void deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* from,
VkPhysicalDeviceCustomBorderColorPropertiesEXT* to);
void deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* from,
VkPhysicalDeviceCustomBorderColorFeaturesEXT* to);
@@ -3413,36 +3955,42 @@
#endif
#ifdef VK_EXT_private_data
void deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePrivateDataFeaturesEXT* from,
VkPhysicalDevicePrivateDataFeaturesEXT* to);
void deepcopy_VkDevicePrivateDataCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDevicePrivateDataCreateInfoEXT* from,
VkDevicePrivateDataCreateInfoEXT* to);
void deepcopy_VkPrivateDataSlotCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPrivateDataSlotCreateInfoEXT* from,
VkPrivateDataSlotCreateInfoEXT* to);
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* from,
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* to);
#endif
#ifdef VK_NV_device_diagnostics_config
void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* from,
VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to);
void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceDiagnosticsConfigCreateInfoNV* from,
VkDeviceDiagnosticsConfigCreateInfoNV* to);
@@ -3451,200 +3999,254 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* from,
VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* to);
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* from,
VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* to);
void deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* from,
VkPipelineFragmentShadingRateEnumStateCreateInfoNV* to);
#endif
#ifdef VK_EXT_fragment_density_map2
void deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* from,
VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* to);
void deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* from,
VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* to);
#endif
#ifdef VK_QCOM_rotated_copy_commands
void deepcopy_VkCopyCommandTransformInfoQCOM(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyCommandTransformInfoQCOM* from,
VkCopyCommandTransformInfoQCOM* to);
#endif
#ifdef VK_EXT_image_robustness
void deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* from,
VkPhysicalDeviceImageRobustnessFeaturesEXT* to);
#endif
#ifdef VK_EXT_4444_formats
void deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* from,
VkPhysicalDevice4444FormatsFeaturesEXT* to);
#endif
#ifdef VK_EXT_directfb_surface
void deepcopy_VkDirectFBSurfaceCreateInfoEXT(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDirectFBSurfaceCreateInfoEXT* from,
VkDirectFBSurfaceCreateInfoEXT* to);
#endif
#ifdef VK_GOOGLE_gfxstream
+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_VkImportPhysicalAddressGOOGLE(
+ Allocator* alloc,
+ VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* from,
+ VkImportPhysicalAddressGOOGLE* to);
+
#endif
#ifdef VK_KHR_acceleration_structure
void deepcopy_VkDeviceOrHostAddressKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceOrHostAddressKHR* from,
VkDeviceOrHostAddressKHR* to);
void deepcopy_VkDeviceOrHostAddressConstKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkDeviceOrHostAddressConstKHR* from,
VkDeviceOrHostAddressConstKHR* to);
void deepcopy_VkAccelerationStructureBuildRangeInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* from,
VkAccelerationStructureBuildRangeInfoKHR* to);
void deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* from,
VkAccelerationStructureGeometryTrianglesDataKHR* to);
void deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryAabbsDataKHR* from,
VkAccelerationStructureGeometryAabbsDataKHR* to);
void deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* from,
VkAccelerationStructureGeometryInstancesDataKHR* to);
void deepcopy_VkAccelerationStructureGeometryDataKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryDataKHR* from,
VkAccelerationStructureGeometryDataKHR* to);
void deepcopy_VkAccelerationStructureGeometryKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryKHR* from,
VkAccelerationStructureGeometryKHR* to);
void deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureBuildGeometryInfoKHR* from,
VkAccelerationStructureBuildGeometryInfoKHR* to);
void deepcopy_VkAccelerationStructureCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoKHR* from,
VkAccelerationStructureCreateInfoKHR* to);
void deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* from,
VkWriteDescriptorSetAccelerationStructureKHR* to);
void deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* from,
VkPhysicalDeviceAccelerationStructureFeaturesKHR* to);
void deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* from,
VkPhysicalDeviceAccelerationStructurePropertiesKHR* to);
void deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* from,
VkAccelerationStructureDeviceAddressInfoKHR* to);
void deepcopy_VkAccelerationStructureVersionInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureVersionInfoKHR* from,
VkAccelerationStructureVersionInfoKHR* to);
void deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* from,
VkCopyAccelerationStructureToMemoryInfoKHR* to);
void deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyMemoryToAccelerationStructureInfoKHR* from,
VkCopyMemoryToAccelerationStructureInfoKHR* to);
void deepcopy_VkCopyAccelerationStructureInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkCopyAccelerationStructureInfoKHR* from,
VkCopyAccelerationStructureInfoKHR* to);
void deepcopy_VkAccelerationStructureBuildSizesInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* from,
VkAccelerationStructureBuildSizesInfoKHR* to);
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoKHR* from,
VkRayTracingShaderGroupCreateInfoKHR* to);
void deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* from,
VkRayTracingPipelineInterfaceCreateInfoKHR* to);
void deepcopy_VkRayTracingPipelineCreateInfoKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoKHR* from,
VkRayTracingPipelineCreateInfoKHR* to);
void deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* from,
VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to);
void deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* from,
VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to);
void deepcopy_VkStridedDeviceAddressRegionKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkStridedDeviceAddressRegionKHR* from,
VkStridedDeviceAddressRegionKHR* to);
void deepcopy_VkTraceRaysIndirectCommandKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkTraceRaysIndirectCommandKHR* from,
VkTraceRaysIndirectCommandKHR* to);
#endif
#ifdef VK_KHR_ray_query
void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(
- BumpPool* pool,
+ Allocator* alloc,
+ VkStructureType rootType,
const VkPhysicalDeviceRayQueryFeaturesKHR* from,
VkPhysicalDeviceRayQueryFeaturesKHR* to);
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
index 9169a98..5984b4d 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -386,7 +386,7 @@
#endif
#ifdef VK_EXT_metal_surface
#endif
-#ifdef VK_GOOGLE_color_buffer
+#ifdef VK_EXT_fragment_density_map
#endif
#ifdef VK_EXT_scalar_block_layout
#endif
@@ -490,6 +490,7 @@
}
size_t goldfish_vk_extension_struct_size(
+ VkStructureType rootType,
const void* structExtension)
{
if (!structExtension)
@@ -1437,18 +1438,79 @@
return sizeof(VkSwapchainDisplayNativeHdrCreateInfoAMD);
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- return sizeof(VkImportColorBufferGOOGLE);
+ switch(rootType)
+ {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
+ {
+ return sizeof(VkImportColorBufferGOOGLE);
+ break;
+ }
+ default:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
+ break;
+ }
+ }
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- return sizeof(VkImportBufferGOOGLE);
+ switch(rootType)
+ {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
+ {
+ return sizeof(VkImportPhysicalAddressGOOGLE);
+ break;
+ }
+ default:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
+ break;
+ }
+ }
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- return sizeof(VkImportPhysicalAddressGOOGLE);
+ switch(rootType)
+ {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ {
+ return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
+ {
+ return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
+ {
+ return sizeof(VkImportBufferGOOGLE);
+ break;
+ }
+ default:
+ {
+ return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
+ break;
+ }
+ }
}
#endif
#ifdef VK_EXT_subgroup_size_control
@@ -1741,6 +1803,20 @@
return sizeof(VkPhysicalDevice4444FormatsFeaturesEXT);
}
#endif
+#ifdef VK_GOOGLE_gfxstream
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+ {
+ return sizeof(VkImportColorBufferGOOGLE);
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ {
+ return sizeof(VkImportBufferGOOGLE);
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ {
+ return sizeof(VkImportPhysicalAddressGOOGLE);
+ }
+#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
@@ -1780,6 +1856,7 @@
size_t goldfish_vk_extension_struct_size_with_stream_features(
uint32_t streamFeatures,
+ VkStructureType rootType,
const void* structExtension)
{
if (!structExtension)
@@ -2734,18 +2811,79 @@
return sizeof(VkSwapchainDisplayNativeHdrCreateInfoAMD);
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- return sizeof(VkImportColorBufferGOOGLE);
+ switch(rootType)
+ {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
+ {
+ return sizeof(VkImportColorBufferGOOGLE);
+ break;
+ }
+ default:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
+ break;
+ }
+ }
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- return sizeof(VkImportBufferGOOGLE);
+ switch(rootType)
+ {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
+ {
+ return sizeof(VkImportPhysicalAddressGOOGLE);
+ break;
+ }
+ default:
+ {
+ return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
+ break;
+ }
+ }
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- return sizeof(VkImportPhysicalAddressGOOGLE);
+ switch(rootType)
+ {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ {
+ return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
+ {
+ return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
+ {
+ return sizeof(VkImportBufferGOOGLE);
+ break;
+ }
+ default:
+ {
+ return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
+ break;
+ }
+ }
}
#endif
#ifdef VK_EXT_subgroup_size_control
@@ -3038,6 +3176,20 @@
return sizeof(VkPhysicalDevice4444FormatsFeaturesEXT);
}
#endif
+#ifdef VK_GOOGLE_gfxstream
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+ {
+ return sizeof(VkImportColorBufferGOOGLE);
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ {
+ return sizeof(VkImportBufferGOOGLE);
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ {
+ return sizeof(VkImportPhysicalAddressGOOGLE);
+ }
+#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
index 1fddc3b..6bae0b8 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -43,10 +43,12 @@
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);
#ifdef VK_VERSION_1_0
@@ -407,7 +409,7 @@
#endif
#ifdef VK_EXT_metal_surface
#endif
-#ifdef VK_GOOGLE_color_buffer
+#ifdef VK_EXT_fragment_density_map
#endif
#ifdef VK_EXT_scalar_block_layout
#endif
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
index aa1de2d..269b50b 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
@@ -6816,10 +6816,10 @@
}
#endif
-#ifdef VK_GOOGLE_color_buffer
-void handlemap_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void handlemap_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
VulkanHandleMapping* handlemap,
- VkImportColorBufferGOOGLE* toMap)
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toMap)
{
(void)handlemap;
(void)toMap;
@@ -6829,9 +6829,9 @@
}
}
-void handlemap_VkImportBufferGOOGLE(
+void handlemap_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
VulkanHandleMapping* handlemap,
- VkImportBufferGOOGLE* toMap)
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toMap)
{
(void)handlemap;
(void)toMap;
@@ -6839,11 +6839,13 @@
{
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minFragmentDensityTexelSize));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxFragmentDensityTexelSize));
}
-void handlemap_VkImportPhysicalAddressGOOGLE(
+void handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(
VulkanHandleMapping* handlemap,
- VkImportPhysicalAddressGOOGLE* toMap)
+ VkRenderPassFragmentDensityMapCreateInfoEXT* toMap)
{
(void)handlemap;
(void)toMap;
@@ -6851,6 +6853,7 @@
{
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
+ handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(&toMap->fragmentDensityMapAttachment));
}
#endif
@@ -7860,6 +7863,42 @@
#endif
#ifdef VK_GOOGLE_gfxstream
+void handlemap_VkImportColorBufferGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkImportColorBufferGOOGLE* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkImportBufferGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkImportBufferGOOGLE* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkImportPhysicalAddressGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkImportPhysicalAddressGOOGLE* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
#endif
#ifdef VK_KHR_acceleration_structure
void handlemap_VkDeviceOrHostAddressKHR(
@@ -9382,20 +9421,20 @@
break;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- handlemap_VkImportColorBufferGOOGLE(handlemap, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ handlemap_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- handlemap_VkImportBufferGOOGLE(handlemap, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ handlemap_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- handlemap_VkImportPhysicalAddressGOOGLE(handlemap, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(handlemap, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
break;
}
#endif
@@ -9745,6 +9784,23 @@
break;
}
#endif
+#ifdef VK_GOOGLE_gfxstream
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ {
+ handlemap_VkImportPhysicalAddressGOOGLE(handlemap, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
index 5362193..9157ecb 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.h
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
@@ -2547,18 +2547,18 @@
VkMetalSurfaceCreateInfoEXT* toMap);
#endif
-#ifdef VK_GOOGLE_color_buffer
-void handlemap_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void handlemap_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
VulkanHandleMapping* handlemap,
- VkImportColorBufferGOOGLE* toMap);
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toMap);
-void handlemap_VkImportBufferGOOGLE(
+void handlemap_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
VulkanHandleMapping* handlemap,
- VkImportBufferGOOGLE* toMap);
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toMap);
-void handlemap_VkImportPhysicalAddressGOOGLE(
+void handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(
VulkanHandleMapping* handlemap,
- VkImportPhysicalAddressGOOGLE* toMap);
+ VkRenderPassFragmentDensityMapCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_scalar_block_layout
@@ -2950,6 +2950,18 @@
#endif
#ifdef VK_GOOGLE_gfxstream
+void handlemap_VkImportColorBufferGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkImportColorBufferGOOGLE* toMap);
+
+void handlemap_VkImportBufferGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkImportBufferGOOGLE* toMap);
+
+void handlemap_VkImportPhysicalAddressGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkImportPhysicalAddressGOOGLE* toMap);
+
#endif
#ifdef VK_KHR_acceleration_structure
void handlemap_VkDeviceOrHostAddressKHR(
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index ab83727..5b1e964 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -33,33 +33,41 @@
void marshal_extension_struct(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const void* structExtension);
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)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)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)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));
@@ -67,8 +75,10 @@
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));
@@ -76,24 +86,30 @@
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)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)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));
@@ -101,8 +117,10 @@
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));
@@ -110,58 +128,92 @@
void marshal_VkRect2D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRect2D* forMarshaling)
{
- marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->offset));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->extent));
+ (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)
{
- unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->offset));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->extent));
+ (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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
@@ -175,10 +227,16 @@
void unmarshal_VkBufferMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferMemoryBarrier* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
@@ -192,8 +250,10 @@
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));
@@ -201,8 +261,10 @@
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));
@@ -210,8 +272,10 @@
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));
vkStream->write((uint32_t*)&forMarshaling->firstIndex, sizeof(uint32_t));
@@ -221,8 +285,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->firstIndex, sizeof(uint32_t));
@@ -232,8 +298,10 @@
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));
vkStream->write((uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
@@ -242,8 +310,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->firstVertex, sizeof(uint32_t));
@@ -252,8 +322,10 @@
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));
vkStream->write((uint32_t*)&forMarshaling->levelCount, sizeof(uint32_t));
@@ -263,8 +335,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->levelCount, sizeof(uint32_t));
@@ -274,10 +348,16 @@
void marshal_VkImageMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageMemoryBarrier* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
@@ -287,15 +367,21 @@
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, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+ marshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}
void unmarshal_VkImageMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageMemoryBarrier* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
@@ -305,33 +391,47 @@
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, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+ unmarshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}
void marshal_VkMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryBarrier* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
}
void unmarshal_VkMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryBarrier* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
}
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);
@@ -353,8 +453,10 @@
void unmarshal_VkAllocationCallbacks(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAllocationCallbacks* forUnmarshaling)
{
+ (void)rootType;
// WARNING PTR CHECK
void* check_pUserData;
check_pUserData = (void*)(uintptr_t)vkStream->getBe64();
@@ -375,10 +477,16 @@
void marshal_VkApplicationInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkApplicationInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
// WARNING PTR CHECK
@@ -414,10 +522,16 @@
void unmarshal_VkApplicationInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkApplicationInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
// WARNING PTR CHECK
@@ -461,8 +575,10 @@
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));
@@ -470,8 +586,10 @@
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));
@@ -479,9 +597,11 @@
void marshal_VkImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageFormatProperties* forMarshaling)
{
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->maxExtent));
+ (void)rootType;
+ marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->maxExtent));
vkStream->write((uint32_t*)&forMarshaling->maxMipLevels, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxArrayLayers, sizeof(uint32_t));
vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleCounts, sizeof(VkSampleCountFlags));
@@ -490,9 +610,11 @@
void unmarshal_VkImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageFormatProperties* forUnmarshaling)
{
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->maxExtent));
+ (void)rootType;
+ unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->maxExtent));
vkStream->read((uint32_t*)&forUnmarshaling->maxMipLevels, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxArrayLayers, sizeof(uint32_t));
vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleCounts, sizeof(VkSampleCountFlags));
@@ -501,17 +623,23 @@
void marshal_VkInstanceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkInstanceCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkInstanceCreateFlags*)&forMarshaling->flags, sizeof(VkInstanceCreateFlags));
// 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, (const VkApplicationInfo*)(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);
@@ -521,10 +649,16 @@
void unmarshal_VkInstanceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkInstanceCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkInstanceCreateFlags*)&forUnmarshaling->flags, sizeof(VkInstanceCreateFlags));
// WARNING PTR CHECK
const VkApplicationInfo* check_pApplicationInfo;
@@ -535,7 +669,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pApplicationInfo inconsistent between guest and host\n");
}
- unmarshal_VkApplicationInfo(vkStream, (VkApplicationInfo*)(forUnmarshaling->pApplicationInfo));
+ unmarshal_VkApplicationInfo(vkStream, rootType, (VkApplicationInfo*)(forUnmarshaling->pApplicationInfo));
}
vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledLayerNames);
@@ -545,40 +679,50 @@
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)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)rootType;
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)rootType;
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)rootType;
vkStream->write((VkBool32*)&forMarshaling->robustBufferAccess, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->fullDrawIndexUint32, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->imageCubeArray, sizeof(VkBool32));
@@ -638,8 +782,10 @@
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));
vkStream->read((VkBool32*)&forUnmarshaling->imageCubeArray, sizeof(VkBool32));
@@ -699,8 +845,10 @@
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));
vkStream->write((uint32_t*)&forMarshaling->maxImageDimension3D, sizeof(uint32_t));
@@ -812,8 +960,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension3D, sizeof(uint32_t));
@@ -924,40 +1074,46 @@
void marshal_VkPhysicalDeviceMemoryProperties(
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)
{
- marshal_VkMemoryType(vkStream, (VkMemoryType*)(forMarshaling->memoryTypes + 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)
{
- marshal_VkMemoryHeap(vkStream, (VkMemoryHeap*)(forMarshaling->memoryHeaps + i));
+ marshal_VkMemoryHeap(vkStream, rootType, (VkMemoryHeap*)(forMarshaling->memoryHeaps + i));
}
}
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, (VkMemoryType*)(forUnmarshaling->memoryTypes + 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, (VkMemoryHeap*)(forUnmarshaling->memoryHeaps + i));
+ unmarshal_VkMemoryHeap(vkStream, rootType, (VkMemoryHeap*)(forUnmarshaling->memoryHeaps + i));
}
}
void marshal_VkPhysicalDeviceSparseProperties(
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->residencyStandard3DBlockShape, sizeof(VkBool32));
@@ -967,8 +1123,10 @@
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->residencyStandard3DBlockShape, sizeof(VkBool32));
@@ -978,8 +1136,10 @@
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));
@@ -987,14 +1147,16 @@
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, (VkPhysicalDeviceLimits*)(&forMarshaling->limits));
- marshal_VkPhysicalDeviceSparseProperties(vkStream, (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)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));
@@ -1002,36 +1164,46 @@
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, (VkPhysicalDeviceLimits*)(&forUnmarshaling->limits));
- unmarshal_VkPhysicalDeviceSparseProperties(vkStream, (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)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, (VkExtent3D*)(&forMarshaling->minImageTransferGranularity));
+ marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->minImageTransferGranularity));
}
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, (VkExtent3D*)(&forUnmarshaling->minImageTransferGranularity));
+ unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->minImageTransferGranularity));
}
void marshal_VkDeviceQueueCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceQueueCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
@@ -1040,10 +1212,16 @@
void unmarshal_VkDeviceQueueCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceQueueCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->queueCount, sizeof(uint32_t));
@@ -1052,17 +1230,23 @@
void marshal_VkDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i));
+ marshal_VkDeviceQueueCreateInfo(vkStream, rootType, (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
@@ -1074,23 +1258,29 @@
vkStream->putBe64(cgen_var_0);
if (forMarshaling->pEnabledFeatures)
{
- marshal_VkPhysicalDeviceFeatures(vkStream, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures));
+ marshal_VkPhysicalDeviceFeatures(vkStream, rootType, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures));
}
}
void unmarshal_VkDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkDeviceQueueCreateInfo*)(forUnmarshaling->pQueueCreateInfos + i));
+ unmarshal_VkDeviceQueueCreateInfo(vkStream, rootType, (VkDeviceQueueCreateInfo*)(forUnmarshaling->pQueueCreateInfos + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
@@ -1106,30 +1296,36 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pEnabledFeatures inconsistent between guest and host\n");
}
- unmarshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(forUnmarshaling->pEnabledFeatures));
+ unmarshal_VkPhysicalDeviceFeatures(vkStream, rootType, (VkPhysicalDeviceFeatures*)(forUnmarshaling->pEnabledFeatures));
}
}
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)rootType;
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)rootType;
vkStream->write((char*)forMarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
vkStream->write((uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->implementationVersion, sizeof(uint32_t));
@@ -1138,8 +1334,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->implementationVersion, sizeof(uint32_t));
@@ -1148,10 +1346,16 @@
void marshal_VkSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubmitInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -1181,10 +1385,16 @@
void unmarshal_VkSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubmitInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -1214,10 +1424,16 @@
void marshal_VkMappedMemoryRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMappedMemoryRange* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -1227,10 +1443,16 @@
void unmarshal_VkMappedMemoryRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMappedMemoryRange* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -1240,28 +1462,42 @@
void marshal_VkMemoryAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryAllocateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
vkStream->write((uint32_t*)&forMarshaling->memoryTypeIndex, sizeof(uint32_t));
}
void unmarshal_VkMemoryAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryAllocateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeIndex, sizeof(uint32_t));
}
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));
@@ -1269,8 +1505,10 @@
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));
@@ -1278,8 +1516,10 @@
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;
@@ -1291,8 +1531,10 @@
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;
@@ -1304,8 +1546,10 @@
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);
@@ -1314,15 +1558,17 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
- marshal_VkSparseMemoryBind(vkStream, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
+ marshal_VkSparseMemoryBind(vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
}
}
}
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);
@@ -1331,15 +1577,17 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
{
- unmarshal_VkSparseMemoryBind(vkStream, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
+ unmarshal_VkSparseMemoryBind(vkStream, rootType, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
}
}
}
void marshal_VkSparseImageOpaqueMemoryBindInfo(
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);
@@ -1348,15 +1596,17 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
- marshal_VkSparseMemoryBind(vkStream, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
+ marshal_VkSparseMemoryBind(vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
}
}
}
void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
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);
@@ -1365,15 +1615,17 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
{
- unmarshal_VkSparseMemoryBind(vkStream, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
+ unmarshal_VkSparseMemoryBind(vkStream, rootType, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
}
}
}
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));
@@ -1381,8 +1633,10 @@
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));
@@ -1390,11 +1644,13 @@
void marshal_VkSparseImageMemoryBind(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryBind* forMarshaling)
{
- marshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forMarshaling->subresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->offset));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+ (void)rootType;
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -1404,11 +1660,13 @@
void unmarshal_VkSparseImageMemoryBind(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageMemoryBind* forUnmarshaling)
{
- unmarshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forUnmarshaling->subresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->offset));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+ (void)rootType;
+ 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);
@@ -1418,8 +1676,10 @@
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);
@@ -1428,15 +1688,17 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
- marshal_VkSparseImageMemoryBind(vkStream, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i));
+ marshal_VkSparseImageMemoryBind(vkStream, rootType, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i));
}
}
}
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);
@@ -1445,17 +1707,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
{
- unmarshal_VkSparseImageMemoryBind(vkStream, (VkSparseImageMemoryBind*)(forUnmarshaling->pBinds + i));
+ unmarshal_VkSparseImageMemoryBind(vkStream, rootType, (VkSparseImageMemoryBind*)(forUnmarshaling->pBinds + i));
}
}
}
void marshal_VkBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindSparseInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -1469,7 +1737,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i)
{
- marshal_VkSparseBufferMemoryBindInfo(vkStream, (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i));
+ marshal_VkSparseBufferMemoryBindInfo(vkStream, rootType, (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->imageOpaqueBindCount, sizeof(uint32_t));
@@ -1477,7 +1745,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i)
{
- marshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i));
+ marshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, rootType, (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->imageBindCount, sizeof(uint32_t));
@@ -1485,7 +1753,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i)
{
- marshal_VkSparseImageMemoryBindInfo(vkStream, (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i));
+ marshal_VkSparseImageMemoryBindInfo(vkStream, rootType, (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
@@ -1500,10 +1768,16 @@
void unmarshal_VkBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindSparseInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -1517,7 +1791,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferBindCount; ++i)
{
- unmarshal_VkSparseBufferMemoryBindInfo(vkStream, (VkSparseBufferMemoryBindInfo*)(forUnmarshaling->pBufferBinds + i));
+ unmarshal_VkSparseBufferMemoryBindInfo(vkStream, rootType, (VkSparseBufferMemoryBindInfo*)(forUnmarshaling->pBufferBinds + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->imageOpaqueBindCount, sizeof(uint32_t));
@@ -1525,7 +1799,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageOpaqueBindCount; ++i)
{
- unmarshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, (VkSparseImageOpaqueMemoryBindInfo*)(forUnmarshaling->pImageOpaqueBinds + i));
+ unmarshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, rootType, (VkSparseImageOpaqueMemoryBindInfo*)(forUnmarshaling->pImageOpaqueBinds + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->imageBindCount, sizeof(uint32_t));
@@ -1533,7 +1807,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageBindCount; ++i)
{
- unmarshal_VkSparseImageMemoryBindInfo(vkStream, (VkSparseImageMemoryBindInfo*)(forUnmarshaling->pImageBinds + i));
+ unmarshal_VkSparseImageMemoryBindInfo(vkStream, rootType, (VkSparseImageMemoryBindInfo*)(forUnmarshaling->pImageBinds + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
@@ -1548,27 +1822,33 @@
void marshal_VkSparseImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageFormatProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->imageGranularity));
+ marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageGranularity));
vkStream->write((VkSparseImageFormatFlags*)&forMarshaling->flags, sizeof(VkSparseImageFormatFlags));
}
void unmarshal_VkSparseImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageFormatProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->imageGranularity));
+ unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageGranularity));
vkStream->read((VkSparseImageFormatFlags*)&forUnmarshaling->flags, sizeof(VkSparseImageFormatFlags));
}
void marshal_VkSparseImageMemoryRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements* forMarshaling)
{
- marshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties));
+ (void)rootType;
+ 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));
@@ -1577,9 +1857,11 @@
void unmarshal_VkSparseImageMemoryRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageMemoryRequirements* forUnmarshaling)
{
- unmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forUnmarshaling->formatProperties));
+ (void)rootType;
+ 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));
@@ -1588,64 +1870,106 @@
void marshal_VkFenceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFenceCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkEventCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkEventCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -1654,10 +1978,16 @@
void unmarshal_VkQueryPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueryPoolCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkQueryType*)&forUnmarshaling->queryType, sizeof(VkQueryType));
vkStream->read((uint32_t*)&forUnmarshaling->queryCount, sizeof(uint32_t));
@@ -1666,10 +1996,16 @@
void marshal_VkBufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
@@ -1686,10 +2022,16 @@
void unmarshal_VkBufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
@@ -1710,10 +2052,16 @@
void marshal_VkBufferViewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferViewCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBufferViewCreateFlags*)&forMarshaling->flags, sizeof(VkBufferViewCreateFlags));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
@@ -1725,10 +2073,16 @@
void unmarshal_VkBufferViewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferViewCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
@@ -1740,14 +2094,20 @@
void marshal_VkImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
vkStream->write((VkImageType*)&forMarshaling->imageType, sizeof(VkImageType));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+ marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
vkStream->write((uint32_t*)&forMarshaling->mipLevels, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->arrayLayers, sizeof(uint32_t));
vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
@@ -1767,14 +2127,20 @@
void unmarshal_VkImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
vkStream->read((VkImageType*)&forUnmarshaling->imageType, sizeof(VkImageType));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+ 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));
@@ -1798,8 +2164,10 @@
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));
vkStream->write((VkDeviceSize*)&forMarshaling->rowPitch, sizeof(VkDeviceSize));
@@ -1809,8 +2177,10 @@
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));
vkStream->read((VkDeviceSize*)&forUnmarshaling->rowPitch, sizeof(VkDeviceSize));
@@ -1820,8 +2190,10 @@
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));
vkStream->write((VkComponentSwizzle*)&forMarshaling->b, sizeof(VkComponentSwizzle));
@@ -1830,8 +2202,10 @@
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));
vkStream->read((VkComponentSwizzle*)&forUnmarshaling->b, sizeof(VkComponentSwizzle));
@@ -1840,42 +2214,60 @@
void marshal_VkImageViewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageViewCreateFlags*)&forMarshaling->flags, sizeof(VkImageViewCreateFlags));
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((VkImageViewType*)&forMarshaling->viewType, sizeof(VkImageViewType));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
- marshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forMarshaling->components));
- marshal_VkImageSubresourceRange(vkStream, (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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
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->read((VkImageViewType*)&forUnmarshaling->viewType, sizeof(VkImageViewType));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
- unmarshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forUnmarshaling->components));
- unmarshal_VkImageSubresourceRange(vkStream, (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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkShaderModuleCreateFlags*)&forMarshaling->flags, sizeof(VkShaderModuleCreateFlags));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->codeSize;
vkStream->putBe64(cgen_var_0);
@@ -1884,10 +2276,16 @@
void unmarshal_VkShaderModuleCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkShaderModuleCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
forUnmarshaling->codeSize = (size_t)vkStream->getBe64();
vkStream->read((uint32_t*)forUnmarshaling->pCode, (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
@@ -1895,10 +2293,16 @@
void marshal_VkPipelineCacheCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCacheCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineCacheCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
vkStream->putBe64(cgen_var_0);
@@ -1907,10 +2311,16 @@
void unmarshal_VkPipelineCacheCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCacheCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
@@ -1918,8 +2328,10 @@
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));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->size;
@@ -1928,8 +2340,10 @@
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();
@@ -1937,14 +2351,16 @@
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, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i));
+ marshal_VkSpecializationMapEntry(vkStream, rootType, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i));
}
}
uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
@@ -1954,14 +2370,16 @@
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, (VkSpecializationMapEntry*)(forUnmarshaling->pMapEntries + i));
+ unmarshal_VkSpecializationMapEntry(vkStream, rootType, (VkSpecializationMapEntry*)(forUnmarshaling->pMapEntries + i));
}
}
forUnmarshaling->dataSize = (size_t)vkStream->getBe64();
@@ -1970,10 +2388,16 @@
void marshal_VkPipelineShaderStageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineShaderStageCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
uint64_t cgen_var_0;
@@ -1985,16 +2409,22 @@
vkStream->putBe64(cgen_var_1);
if (forMarshaling->pSpecializationInfo)
{
- marshal_VkSpecializationInfo(vkStream, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
+ marshal_VkSpecializationInfo(vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
}
}
void unmarshal_VkPipelineShaderStageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineShaderStageCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkShaderStageFlagBits*)&forUnmarshaling->stage, sizeof(VkShaderStageFlagBits));
uint64_t cgen_var_0;
@@ -2010,18 +2440,24 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pSpecializationInfo inconsistent between guest and host\n");
}
- unmarshal_VkSpecializationInfo(vkStream, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
+ unmarshal_VkSpecializationInfo(vkStream, rootType, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
}
}
void marshal_VkComputePipelineCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkComputePipelineCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -2033,12 +2469,18 @@
void unmarshal_VkComputePipelineCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkComputePipelineCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (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);
@@ -2050,8 +2492,10 @@
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));
@@ -2059,8 +2503,10 @@
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));
vkStream->read((VkVertexInputRate*)&forUnmarshaling->inputRate, sizeof(VkVertexInputRate));
@@ -2068,8 +2514,10 @@
void marshal_VkVertexInputAttributeDescription(
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));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
@@ -2078,8 +2526,10 @@
void unmarshal_VkVertexInputAttributeDescription(
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));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
@@ -2088,17 +2538,23 @@
void marshal_VkPipelineVertexInputStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineVertexInputStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
if (forMarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i)
{
- marshal_VkVertexInputBindingDescription(vkStream, (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i));
+ marshal_VkVertexInputBindingDescription(vkStream, rootType, (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
@@ -2106,24 +2562,30 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i)
{
- marshal_VkVertexInputAttributeDescription(vkStream, (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions + i));
+ marshal_VkVertexInputAttributeDescription(vkStream, rootType, (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions + i));
}
}
}
void unmarshal_VkPipelineVertexInputStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineVertexInputStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
if (forUnmarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDescriptionCount; ++i)
{
- unmarshal_VkVertexInputBindingDescription(vkStream, (VkVertexInputBindingDescription*)(forUnmarshaling->pVertexBindingDescriptions + i));
+ unmarshal_VkVertexInputBindingDescription(vkStream, rootType, (VkVertexInputBindingDescription*)(forUnmarshaling->pVertexBindingDescriptions + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
@@ -2131,17 +2593,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexAttributeDescriptionCount; ++i)
{
- unmarshal_VkVertexInputAttributeDescription(vkStream, (VkVertexInputAttributeDescription*)(forUnmarshaling->pVertexAttributeDescriptions + i));
+ unmarshal_VkVertexInputAttributeDescription(vkStream, rootType, (VkVertexInputAttributeDescription*)(forUnmarshaling->pVertexAttributeDescriptions + i));
}
}
}
void marshal_VkPipelineInputAssemblyStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineInputAssemblyStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkPrimitiveTopology*)&forMarshaling->topology, sizeof(VkPrimitiveTopology));
vkStream->write((VkBool32*)&forMarshaling->primitiveRestartEnable, sizeof(VkBool32));
@@ -2149,10 +2617,16 @@
void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkPrimitiveTopology*)&forUnmarshaling->topology, sizeof(VkPrimitiveTopology));
vkStream->read((VkBool32*)&forUnmarshaling->primitiveRestartEnable, sizeof(VkBool32));
@@ -2160,28 +2634,42 @@
void marshal_VkPipelineTessellationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineTessellationStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
}
void unmarshal_VkPipelineTessellationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineTessellationStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->patchControlPoints, sizeof(uint32_t));
}
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));
vkStream->write((float*)&forMarshaling->width, sizeof(float));
@@ -2192,8 +2680,10 @@
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));
vkStream->read((float*)&forUnmarshaling->width, sizeof(float));
@@ -2204,10 +2694,16 @@
void marshal_VkPipelineViewportStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -2219,7 +2715,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
{
- marshal_VkViewport(vkStream, (const VkViewport*)(forMarshaling->pViewports + i));
+ marshal_VkViewport(vkStream, rootType, (const VkViewport*)(forMarshaling->pViewports + i));
}
}
}
@@ -2233,7 +2729,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i)
{
- marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pScissors + i));
+ marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pScissors + i));
}
}
}
@@ -2241,10 +2737,16 @@
void unmarshal_VkPipelineViewportStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -2260,7 +2762,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
{
- unmarshal_VkViewport(vkStream, (VkViewport*)(forUnmarshaling->pViewports + i));
+ unmarshal_VkViewport(vkStream, rootType, (VkViewport*)(forUnmarshaling->pViewports + i));
}
}
}
@@ -2278,7 +2780,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->scissorCount; ++i)
{
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pScissors + i));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pScissors + i));
}
}
}
@@ -2286,10 +2788,16 @@
void marshal_VkPipelineRasterizationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->depthClampEnable, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
@@ -2305,10 +2813,16 @@
void unmarshal_VkPipelineRasterizationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->depthClampEnable, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
@@ -2324,10 +2838,16 @@
void marshal_VkPipelineMultisampleStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineMultisampleStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->sampleShadingEnable, sizeof(VkBool32));
@@ -2345,10 +2865,16 @@
void unmarshal_VkPipelineMultisampleStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineMultisampleStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->sampleShadingEnable, sizeof(VkBool32));
@@ -2370,8 +2896,10 @@
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));
vkStream->write((VkStencilOp*)&forMarshaling->depthFailOp, sizeof(VkStencilOp));
@@ -2383,8 +2911,10 @@
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));
vkStream->read((VkStencilOp*)&forUnmarshaling->depthFailOp, sizeof(VkStencilOp));
@@ -2396,44 +2926,58 @@
void marshal_VkPipelineDepthStencilStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDepthStencilStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->depthTestEnable, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->depthWriteEnable, sizeof(VkBool32));
vkStream->write((VkCompareOp*)&forMarshaling->depthCompareOp, sizeof(VkCompareOp));
vkStream->write((VkBool32*)&forMarshaling->depthBoundsTestEnable, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->stencilTestEnable, sizeof(VkBool32));
- marshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forMarshaling->front));
- marshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forMarshaling->back));
+ marshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->front));
+ marshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->back));
vkStream->write((float*)&forMarshaling->minDepthBounds, sizeof(float));
vkStream->write((float*)&forMarshaling->maxDepthBounds, sizeof(float));
}
void unmarshal_VkPipelineDepthStencilStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineDepthStencilStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->depthTestEnable, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->depthWriteEnable, sizeof(VkBool32));
vkStream->read((VkCompareOp*)&forUnmarshaling->depthCompareOp, sizeof(VkCompareOp));
vkStream->read((VkBool32*)&forUnmarshaling->depthBoundsTestEnable, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->stencilTestEnable, sizeof(VkBool32));
- unmarshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forUnmarshaling->front));
- unmarshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forUnmarshaling->back));
+ unmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forUnmarshaling->front));
+ unmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forUnmarshaling->back));
vkStream->read((float*)&forUnmarshaling->minDepthBounds, sizeof(float));
vkStream->read((float*)&forUnmarshaling->maxDepthBounds, sizeof(float));
}
void marshal_VkPipelineColorBlendAttachmentState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendAttachmentState* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkBool32*)&forMarshaling->blendEnable, sizeof(VkBool32));
vkStream->write((VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
vkStream->write((VkBlendFactor*)&forMarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
@@ -2446,8 +2990,10 @@
void unmarshal_VkPipelineColorBlendAttachmentState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineColorBlendAttachmentState* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkBool32*)&forUnmarshaling->blendEnable, sizeof(VkBool32));
vkStream->read((VkBlendFactor*)&forUnmarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
vkStream->read((VkBlendFactor*)&forUnmarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
@@ -2460,10 +3006,16 @@
void marshal_VkPipelineColorBlendStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->logicOpEnable, sizeof(VkBool32));
vkStream->write((VkLogicOp*)&forMarshaling->logicOp, sizeof(VkLogicOp));
@@ -2472,7 +3024,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
{
- marshal_VkPipelineColorBlendAttachmentState(vkStream, (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i));
+ marshal_VkPipelineColorBlendAttachmentState(vkStream, rootType, (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i));
}
}
vkStream->write((float*)forMarshaling->blendConstants, 4 * sizeof(float));
@@ -2480,10 +3032,16 @@
void unmarshal_VkPipelineColorBlendStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineColorBlendStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->logicOpEnable, sizeof(VkBool32));
vkStream->read((VkLogicOp*)&forUnmarshaling->logicOp, sizeof(VkLogicOp));
@@ -2492,7 +3050,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
{
- unmarshal_VkPipelineColorBlendAttachmentState(vkStream, (VkPipelineColorBlendAttachmentState*)(forUnmarshaling->pAttachments + i));
+ unmarshal_VkPipelineColorBlendAttachmentState(vkStream, rootType, (VkPipelineColorBlendAttachmentState*)(forUnmarshaling->pAttachments + i));
}
}
vkStream->read((float*)forUnmarshaling->blendConstants, 4 * sizeof(float));
@@ -2500,10 +3058,16 @@
void marshal_VkPipelineDynamicStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDynamicStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->dynamicStateCount, sizeof(uint32_t));
vkStream->write((const VkDynamicState*)forMarshaling->pDynamicStates, forMarshaling->dynamicStateCount * sizeof(const VkDynamicState));
@@ -2511,10 +3075,16 @@
void unmarshal_VkPipelineDynamicStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineDynamicStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->dynamicStateCount, sizeof(uint32_t));
vkStream->read((VkDynamicState*)forUnmarshaling->pDynamicStates, forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
@@ -2522,8 +3092,10 @@
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)
{
@@ -2539,14 +3111,18 @@
vkStream->putBe32(cgen_var_0);
}
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
}
// WARNING PTR CHECK
@@ -2557,7 +3133,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pVertexInputState))
{
- marshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
+ marshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
}
// WARNING PTR CHECK
if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
@@ -2567,7 +3143,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pInputAssemblyState))
{
- marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
+ marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, rootType, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
@@ -2576,7 +3152,7 @@
{
if (hasTessellation)
{
- marshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+ marshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
}
}
// WARNING PTR CHECK
@@ -2586,7 +3162,7 @@
{
if (hasRasterization)
{
- marshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
+ marshal_VkPipelineViewportStateCreateInfo(vkStream, rootType, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
}
}
// WARNING PTR CHECK
@@ -2597,7 +3173,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pRasterizationState))
{
- marshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
+ marshal_VkPipelineRasterizationStateCreateInfo(vkStream, rootType, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
@@ -2606,7 +3182,7 @@
{
if (hasRasterization)
{
- marshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
+ marshal_VkPipelineMultisampleStateCreateInfo(vkStream, rootType, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
}
}
// WARNING PTR CHECK
@@ -2616,7 +3192,7 @@
{
if (hasRasterization)
{
- marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
+ marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, rootType, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
}
}
// WARNING PTR CHECK
@@ -2626,7 +3202,7 @@
{
if (hasRasterization)
{
- marshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
+ marshal_VkPipelineColorBlendStateCreateInfo(vkStream, rootType, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
}
}
// WARNING PTR CHECK
@@ -2634,7 +3210,7 @@
vkStream->putBe64(cgen_var_5);
if (forMarshaling->pDynamicState)
{
- marshal_VkPipelineDynamicStateCreateInfo(vkStream, (const VkPipelineDynamicStateCreateInfo*)(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);
@@ -2651,8 +3227,10 @@
void unmarshal_VkGraphicsPipelineCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGraphicsPipelineCreateInfo* forUnmarshaling)
{
+ (void)rootType;
uint32_t hasRasterization = 1;
if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
{
@@ -2664,14 +3242,18 @@
hasTessellation = (const uint32_t)vkStream->getBe32();
}
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
}
// WARNING PTR CHECK
@@ -2682,7 +3264,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pVertexInputState))
{
- unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
+ unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
}
// WARNING PTR CHECK
const VkPipelineInputAssemblyStateCreateInfo* check_pInputAssemblyState;
@@ -2692,7 +3274,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pInputAssemblyState))
{
- unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
+ unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, rootType, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
}
// WARNING PTR CHECK
const VkPipelineTessellationStateCreateInfo* check_pTessellationState;
@@ -2705,7 +3287,7 @@
}
if (hasTessellation)
{
- unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+ unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
}
else
{
@@ -2723,7 +3305,7 @@
}
if (hasRasterization)
{
- unmarshal_VkPipelineViewportStateCreateInfo(vkStream, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
+ unmarshal_VkPipelineViewportStateCreateInfo(vkStream, rootType, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
}
else
{
@@ -2738,7 +3320,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pRasterizationState))
{
- unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
+ unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, rootType, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
}
// WARNING PTR CHECK
const VkPipelineMultisampleStateCreateInfo* check_pMultisampleState;
@@ -2751,7 +3333,7 @@
}
if (hasRasterization)
{
- unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
+ unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, rootType, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
}
else
{
@@ -2769,7 +3351,7 @@
}
if (hasRasterization)
{
- unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
+ unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, rootType, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
}
else
{
@@ -2787,7 +3369,7 @@
}
if (hasRasterization)
{
- unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
+ unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, rootType, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
}
else
{
@@ -2803,7 +3385,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pDynamicState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
+ unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
}
uint64_t cgen_var_6;
vkStream->read((uint64_t*)&cgen_var_6, 1 * 8);
@@ -2820,8 +3402,10 @@
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));
@@ -2829,8 +3413,10 @@
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));
@@ -2838,10 +3424,16 @@
void marshal_VkPipelineLayoutCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineLayoutCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
if (forMarshaling->setLayoutCount)
@@ -2856,17 +3448,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
{
- marshal_VkPushConstantRange(vkStream, (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
+ marshal_VkPushConstantRange(vkStream, rootType, (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
}
}
}
void unmarshal_VkPipelineLayoutCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineLayoutCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
if (forUnmarshaling->setLayoutCount)
@@ -2881,17 +3479,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i)
{
- unmarshal_VkPushConstantRange(vkStream, (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
+ unmarshal_VkPushConstantRange(vkStream, rootType, (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
}
}
}
void marshal_VkSamplerCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSamplerCreateFlags*)&forMarshaling->flags, sizeof(VkSamplerCreateFlags));
vkStream->write((VkFilter*)&forMarshaling->magFilter, sizeof(VkFilter));
vkStream->write((VkFilter*)&forMarshaling->minFilter, sizeof(VkFilter));
@@ -2912,10 +3516,16 @@
void unmarshal_VkSamplerCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkSamplerCreateFlags*)&forUnmarshaling->flags, sizeof(VkSamplerCreateFlags));
vkStream->read((VkFilter*)&forUnmarshaling->magFilter, sizeof(VkFilter));
vkStream->read((VkFilter*)&forUnmarshaling->minFilter, sizeof(VkFilter));
@@ -2936,10 +3546,16 @@
void marshal_VkCopyDescriptorSet(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyDescriptorSet* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -2955,10 +3571,16 @@
void unmarshal_VkCopyDescriptorSet(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyDescriptorSet* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -2974,8 +3596,10 @@
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);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -2985,8 +3609,10 @@
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);
@@ -2996,8 +3622,10 @@
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);
@@ -3009,8 +3637,10 @@
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);
@@ -3022,26 +3652,36 @@
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)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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->maxSets, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->poolSizeCount, sizeof(uint32_t));
@@ -3049,17 +3689,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i)
{
- marshal_VkDescriptorPoolSize(vkStream, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i));
+ marshal_VkDescriptorPoolSize(vkStream, rootType, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i));
}
}
}
void unmarshal_VkDescriptorPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorPoolCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->maxSets, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->poolSizeCount, sizeof(uint32_t));
@@ -3067,17 +3713,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->poolSizeCount; ++i)
{
- unmarshal_VkDescriptorPoolSize(vkStream, (VkDescriptorPoolSize*)(forUnmarshaling->pPoolSizes + i));
+ unmarshal_VkDescriptorPoolSize(vkStream, rootType, (VkDescriptorPoolSize*)(forUnmarshaling->pPoolSizes + i));
}
}
}
void marshal_VkDescriptorSetAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetAllocateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -3093,10 +3745,16 @@
void unmarshal_VkDescriptorSetAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetAllocateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -3112,8 +3770,10 @@
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));
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
@@ -3135,8 +3795,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
@@ -3162,44 +3824,62 @@
void marshal_VkDescriptorSetLayoutCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
if (forMarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i)
{
- marshal_VkDescriptorSetLayoutBinding(vkStream, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i));
+ marshal_VkDescriptorSetLayoutBinding(vkStream, rootType, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i));
}
}
}
void unmarshal_VkDescriptorSetLayoutCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetLayoutCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
if (forUnmarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindingCount; ++i)
{
- unmarshal_VkDescriptorSetLayoutBinding(vkStream, (VkDescriptorSetLayoutBinding*)(forUnmarshaling->pBindings + i));
+ unmarshal_VkDescriptorSetLayoutBinding(vkStream, rootType, (VkDescriptorSetLayoutBinding*)(forUnmarshaling->pBindings + i));
}
}
}
void marshal_VkWriteDescriptorSet(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSet* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -3218,7 +3898,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
{
- marshal_VkDescriptorImageInfo(vkStream, (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i));
+ marshal_VkDescriptorImageInfo(vkStream, rootType, (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i));
}
}
}
@@ -3234,7 +3914,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
{
- marshal_VkDescriptorBufferInfo(vkStream, (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i));
+ marshal_VkDescriptorBufferInfo(vkStream, rootType, (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i));
}
}
}
@@ -3259,10 +3939,16 @@
void unmarshal_VkWriteDescriptorSet(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWriteDescriptorSet* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -3285,7 +3971,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
{
- unmarshal_VkDescriptorImageInfo(vkStream, (VkDescriptorImageInfo*)(forUnmarshaling->pImageInfo + i));
+ unmarshal_VkDescriptorImageInfo(vkStream, rootType, (VkDescriptorImageInfo*)(forUnmarshaling->pImageInfo + i));
}
}
}
@@ -3309,7 +3995,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
{
- unmarshal_VkDescriptorBufferInfo(vkStream, (VkDescriptorBufferInfo*)(forUnmarshaling->pBufferInfo + i));
+ unmarshal_VkDescriptorBufferInfo(vkStream, rootType, (VkDescriptorBufferInfo*)(forUnmarshaling->pBufferInfo + i));
}
}
}
@@ -3346,8 +4032,10 @@
void marshal_VkAttachmentDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentDescription* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
@@ -3361,8 +4049,10 @@
void unmarshal_VkAttachmentDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentDescription* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
@@ -3376,26 +4066,36 @@
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)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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0, 1);
@@ -3415,10 +4115,16 @@
void unmarshal_VkFramebufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFramebufferCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
@@ -3438,8 +4144,10 @@
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((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
@@ -3447,7 +4155,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
{
- marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i));
+ marshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
@@ -3455,7 +4163,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
{
- marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
+ marshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
@@ -3467,7 +4175,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
{
- marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i));
+ marshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i));
}
}
}
@@ -3476,7 +4184,7 @@
vkStream->putBe64(cgen_var_1);
if (forMarshaling->pDepthStencilAttachment)
{
- marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(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));
@@ -3484,8 +4192,10 @@
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((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
@@ -3493,7 +4203,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i)
{
- unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pInputAttachments + i));
+ unmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pInputAttachments + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
@@ -3501,7 +4211,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
{
- unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pColorAttachments + i));
+ unmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
@@ -3517,7 +4227,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
{
- unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pResolveAttachments + i));
+ unmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pResolveAttachments + i));
}
}
}
@@ -3530,7 +4240,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilAttachment inconsistent between guest and host\n");
}
- unmarshal_VkAttachmentReference(vkStream, (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));
@@ -3538,8 +4248,10 @@
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));
@@ -3551,8 +4263,10 @@
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));
@@ -3564,17 +4278,23 @@
void marshal_VkRenderPassCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
if (forMarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
{
- marshal_VkAttachmentDescription(vkStream, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i));
+ marshal_VkAttachmentDescription(vkStream, rootType, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
@@ -3582,7 +4302,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
{
- marshal_VkSubpassDescription(vkStream, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i));
+ marshal_VkSubpassDescription(vkStream, rootType, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
@@ -3590,24 +4310,30 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
{
- marshal_VkSubpassDependency(vkStream, (const VkSubpassDependency*)(forMarshaling->pDependencies + i));
+ marshal_VkSubpassDependency(vkStream, rootType, (const VkSubpassDependency*)(forMarshaling->pDependencies + i));
}
}
}
void unmarshal_VkRenderPassCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
if (forUnmarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
{
- unmarshal_VkAttachmentDescription(vkStream, (VkAttachmentDescription*)(forUnmarshaling->pAttachments + i));
+ unmarshal_VkAttachmentDescription(vkStream, rootType, (VkAttachmentDescription*)(forUnmarshaling->pAttachments + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
@@ -3615,7 +4341,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i)
{
- unmarshal_VkSubpassDescription(vkStream, (VkSubpassDescription*)(forUnmarshaling->pSubpasses + i));
+ unmarshal_VkSubpassDescription(vkStream, rootType, (VkSubpassDescription*)(forUnmarshaling->pSubpasses + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
@@ -3623,37 +4349,55 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i)
{
- unmarshal_VkSubpassDependency(vkStream, (VkSubpassDependency*)(forUnmarshaling->pDependencies + i));
+ unmarshal_VkSubpassDependency(vkStream, rootType, (VkSubpassDependency*)(forUnmarshaling->pDependencies + i));
}
}
}
void marshal_VkCommandPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandPoolCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
}
void unmarshal_VkCommandPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandPoolCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
}
void marshal_VkCommandBufferAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferAllocateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -3663,10 +4407,16 @@
void unmarshal_VkCommandBufferAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferAllocateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -3676,10 +4426,16 @@
void marshal_VkCommandBufferInheritanceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -3694,10 +4450,16 @@
void unmarshal_VkCommandBufferInheritanceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferInheritanceInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -3712,26 +4474,38 @@
void marshal_VkCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferBeginInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
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, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
+ marshal_VkCommandBufferInheritanceInfo(vkStream, rootType, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
}
}
void unmarshal_VkCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferBeginInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
const VkCommandBufferInheritanceInfo* check_pInheritanceInfo;
@@ -3742,14 +4516,16 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pInheritanceInfo inconsistent between guest and host\n");
}
- unmarshal_VkCommandBufferInheritanceInfo(vkStream, (VkCommandBufferInheritanceInfo*)(forUnmarshaling->pInheritanceInfo));
+ unmarshal_VkCommandBufferInheritanceInfo(vkStream, rootType, (VkCommandBufferInheritanceInfo*)(forUnmarshaling->pInheritanceInfo));
}
}
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));
@@ -3757,8 +4533,10 @@
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));
@@ -3766,8 +4544,10 @@
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));
vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
@@ -3776,8 +4556,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
@@ -3786,197 +4568,239 @@
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, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->imageOffset));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->imageExtent));
+ 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)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, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->imageOffset));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+ 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)rootType;
vkStream->write((float*)forMarshaling->float32, 4 * sizeof(float));
}
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)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)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)
{
- marshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forMarshaling->color));
+ (void)rootType;
+ marshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forMarshaling->color));
}
void unmarshal_VkClearValue(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkClearValue* forUnmarshaling)
{
- unmarshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forUnmarshaling->color));
+ (void)rootType;
+ unmarshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forUnmarshaling->color));
}
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, (VkClearValue*)(&forMarshaling->clearValue));
+ marshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue));
}
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, (VkClearValue*)(&forUnmarshaling->clearValue));
+ unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forUnmarshaling->clearValue));
}
void marshal_VkClearRect(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkClearRect* forMarshaling)
{
- marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->rect));
+ (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)
{
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->rect));
+ (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)
{
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ (void)rootType;
+ marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->srcOffsets + i));
+ marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i));
}
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->dstOffsets + i));
+ marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i));
}
}
void unmarshal_VkImageBlit(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageBlit* forUnmarshaling)
{
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ (void)rootType;
+ unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
+ unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
}
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
+ unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
}
}
void marshal_VkImageCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageCopy* forMarshaling)
{
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset));
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+ (void)rootType;
+ marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
+ 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)
{
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->srcOffset));
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->dstOffset));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+ (void)rootType;
+ unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
+ 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)
{
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset));
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+ (void)rootType;
+ marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
+ 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)
{
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->srcOffset));
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->dstOffset));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+ (void)rootType;
+ unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->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->write((uint64_t*)&cgen_var_1, 1 * 8);
- marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea));
+ 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;
@@ -3987,7 +4811,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
{
- marshal_VkClearValue(vkStream, (const VkClearValue*)(forMarshaling->pClearValues + i));
+ marshal_VkClearValue(vkStream, rootType, (const VkClearValue*)(forMarshaling->pClearValues + i));
}
}
}
@@ -3995,17 +4819,23 @@
void unmarshal_VkRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassBeginInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
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);
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->renderArea));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
vkStream->read((uint32_t*)&forUnmarshaling->clearValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkClearValue* check_pClearValues;
@@ -4020,7 +4850,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->clearValueCount; ++i)
{
- unmarshal_VkClearValue(vkStream, (VkClearValue*)(forUnmarshaling->pClearValues + i));
+ unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(forUnmarshaling->pClearValues + i));
}
}
}
@@ -4030,10 +4860,16 @@
#ifdef VK_VERSION_1_1
void marshal_VkPhysicalDeviceSubgroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -4042,10 +4878,16 @@
void unmarshal_VkPhysicalDeviceSubgroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSubgroupProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -4054,10 +4896,16 @@
void marshal_VkBindBufferMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindBufferMemoryInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -4069,10 +4917,16 @@
void unmarshal_VkBindBufferMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindBufferMemoryInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -4084,10 +4938,16 @@
void marshal_VkBindImageMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemoryInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -4099,10 +4959,16 @@
void unmarshal_VkBindImageMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindImageMemoryInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -4114,10 +4980,16 @@
void marshal_VkPhysicalDevice16BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice16BitStorageFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->storagePushConstant16, sizeof(VkBool32));
@@ -4126,10 +4998,16 @@
void unmarshal_VkPhysicalDevice16BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevice16BitStorageFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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->storagePushConstant16, sizeof(VkBool32));
@@ -4138,30 +5016,48 @@
void marshal_VkMemoryDedicatedRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryDedicatedRequirements* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
}
void unmarshal_VkMemoryDedicatedRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryDedicatedRequirements* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
}
void marshal_VkMemoryDedicatedAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryDedicatedAllocateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -4172,10 +5068,16 @@
void unmarshal_VkMemoryDedicatedAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryDedicatedAllocateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -4186,82 +5088,124 @@
void marshal_VkMemoryAllocateFlagsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryAllocateFlagsInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkMemoryAllocateFlags*)&forMarshaling->flags, sizeof(VkMemoryAllocateFlags));
vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}
void unmarshal_VkMemoryAllocateFlagsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryAllocateFlagsInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkMemoryAllocateFlags*)&forUnmarshaling->flags, sizeof(VkMemoryAllocateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}
void marshal_VkDeviceGroupRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupRenderPassBeginInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i));
+ marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i));
}
}
}
void unmarshal_VkDeviceGroupRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupRenderPassBeginInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkRect2D*)(forUnmarshaling->pDeviceRenderAreas + i));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pDeviceRenderAreas + i));
}
}
}
void marshal_VkDeviceGroupCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupCommandBufferBeginInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
@@ -4272,10 +5216,16 @@
void unmarshal_VkDeviceGroupSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupSubmitInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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->commandBufferCount, sizeof(uint32_t));
@@ -4286,50 +5236,80 @@
void marshal_VkDeviceGroupBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupBindSparseInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->resourceDeviceIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->memoryDeviceIndex, sizeof(uint32_t));
}
void unmarshal_VkDeviceGroupBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupBindSparseInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->resourceDeviceIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->memoryDeviceIndex, sizeof(uint32_t));
}
void marshal_VkBindBufferMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindBufferMemoryDeviceGroupInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkBindImageMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemoryDeviceGroupInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
@@ -4337,17 +5317,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i)
{
- marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i));
+ marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i));
}
}
}
void unmarshal_VkBindImageMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindImageMemoryDeviceGroupInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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->splitInstanceBindRegionCount, sizeof(uint32_t));
@@ -4355,17 +5341,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->splitInstanceBindRegionCount; ++i)
{
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pSplitInstanceBindRegions + i));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pSplitInstanceBindRegions + i));
}
}
}
void marshal_VkPhysicalDeviceGroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceGroupProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->subsetAllocation, sizeof(VkBool32));
@@ -4373,10 +5365,16 @@
void unmarshal_VkPhysicalDeviceGroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceGroupProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->subsetAllocation, sizeof(VkBool32));
@@ -4384,10 +5382,16 @@
void marshal_VkDeviceGroupDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupDeviceCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -4400,10 +5404,16 @@
void unmarshal_VkDeviceGroupDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupDeviceCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -4416,10 +5426,16 @@
void marshal_VkBufferMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferMemoryRequirementsInfo2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -4427,10 +5443,16 @@
void unmarshal_VkBufferMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferMemoryRequirementsInfo2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -4438,10 +5460,16 @@
void marshal_VkImageMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageMemoryRequirementsInfo2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -4449,10 +5477,16 @@
void unmarshal_VkImageMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageMemoryRequirementsInfo2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -4460,10 +5494,16 @@
void marshal_VkImageSparseMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSparseMemoryRequirementsInfo2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -4471,10 +5511,16 @@
void unmarshal_VkImageSparseMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageSparseMemoryRequirementsInfo2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -4482,118 +5528,196 @@
void marshal_VkMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryRequirements2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkMemoryRequirements(vkStream, rootType, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
}
void unmarshal_VkMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryRequirements2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
+ 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));
}
void marshal_VkSparseImageMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkSparseImageMemoryRequirements(vkStream, rootType, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements));
}
void unmarshal_VkSparseImageMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageMemoryRequirements2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
+ 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));
}
void marshal_VkPhysicalDeviceFeatures2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forMarshaling->features));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkPhysicalDeviceFeatures(vkStream, rootType, (VkPhysicalDeviceFeatures*)(&forMarshaling->features));
}
void unmarshal_VkPhysicalDeviceFeatures2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFeatures2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forUnmarshaling->features));
+ 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));
}
void marshal_VkPhysicalDeviceProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProperties2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forMarshaling->properties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkPhysicalDeviceProperties(vkStream, rootType, (VkPhysicalDeviceProperties*)(&forMarshaling->properties));
}
void unmarshal_VkPhysicalDeviceProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceProperties2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forUnmarshaling->properties));
+ 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));
}
void marshal_VkFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFormatProperties2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forMarshaling->formatProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkFormatProperties(vkStream, rootType, (VkFormatProperties*)(&forMarshaling->formatProperties));
}
void unmarshal_VkFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFormatProperties2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forUnmarshaling->formatProperties));
+ 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));
}
void marshal_VkImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageFormatProperties2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkImageFormatProperties(vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
}
void unmarshal_VkImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageFormatProperties2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
+ 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));
}
void marshal_VkPhysicalDeviceImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageFormatInfo2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkImageType*)&forMarshaling->type, sizeof(VkImageType));
vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
@@ -4603,10 +5727,16 @@
void unmarshal_VkPhysicalDeviceImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImageFormatInfo2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
@@ -4616,64 +5746,106 @@
void marshal_VkQueueFamilyProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueueFamilyProperties2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkQueueFamilyProperties(vkStream, rootType, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties));
}
void unmarshal_VkQueueFamilyProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueueFamilyProperties2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forUnmarshaling->queueFamilyProperties));
+ 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));
}
void marshal_VkPhysicalDeviceMemoryProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkPhysicalDeviceMemoryProperties(vkStream, rootType, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties));
}
void unmarshal_VkPhysicalDeviceMemoryProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMemoryProperties2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forUnmarshaling->memoryProperties));
+ 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));
}
void marshal_VkSparseImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageFormatProperties2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->properties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkSparseImageFormatProperties(vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->properties));
}
void unmarshal_VkSparseImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageFormatProperties2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forUnmarshaling->properties));
+ 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));
}
void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkImageType*)&forMarshaling->type, sizeof(VkImageType));
vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
@@ -4683,10 +5855,16 @@
void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -4696,26 +5874,40 @@
void marshal_VkPhysicalDevicePointClippingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePointClippingProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
}
void unmarshal_VkPhysicalDevicePointClippingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePointClippingProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkInputAttachmentAspectReference(
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));
@@ -4723,8 +5915,10 @@
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));
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
@@ -4732,78 +5926,120 @@
void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i));
+ marshal_VkInputAttachmentAspectReference(vkStream, rootType, (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i));
}
}
}
void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkInputAttachmentAspectReference*)(forUnmarshaling->pAspectReferences + i));
+ unmarshal_VkInputAttachmentAspectReference(vkStream, rootType, (VkInputAttachmentAspectReference*)(forUnmarshaling->pAspectReferences + i));
}
}
}
void marshal_VkImageViewUsageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewUsageCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
}
void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkTessellationDomainOrigin*)&forMarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
}
void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkRenderPassMultiviewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassMultiviewCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
@@ -4814,10 +6050,16 @@
void unmarshal_VkRenderPassMultiviewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassMultiviewCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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->dependencyCount, sizeof(uint32_t));
@@ -4828,10 +6070,16 @@
void marshal_VkPhysicalDeviceMultiviewFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->multiviewGeometryShader, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->multiviewTessellationShader, sizeof(VkBool32));
@@ -4839,10 +6087,16 @@
void unmarshal_VkPhysicalDeviceMultiviewFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMultiviewFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->multiview, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->multiviewGeometryShader, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->multiviewTessellationShader, sizeof(VkBool32));
@@ -4850,86 +6104,140 @@
void marshal_VkPhysicalDeviceMultiviewProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceMultiviewProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMultiviewProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewViewCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
}
void marshal_VkPhysicalDeviceVariablePointersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceVariablePointersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVariablePointersFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->variablePointers, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->protectedMemory, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceProtectedMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->queueIndex, sizeof(uint32_t));
@@ -4937,10 +6245,16 @@
void unmarshal_VkDeviceQueueInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceQueueInfo2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->queueIndex, sizeof(uint32_t));
@@ -4948,32 +6262,50 @@
void marshal_VkProtectedSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkProtectedSubmitInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->protectedSubmit, sizeof(VkBool32));
}
void marshal_VkSamplerYcbcrConversionCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkSamplerYcbcrRange*)&forMarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
- marshal_VkComponentMapping(vkStream, (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));
@@ -4982,14 +6314,20 @@
void unmarshal_VkSamplerYcbcrConversionCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerYcbcrConversionCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkSamplerYcbcrRange*)&forUnmarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
- unmarshal_VkComponentMapping(vkStream, (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));
@@ -4998,10 +6336,16 @@
void marshal_VkSamplerYcbcrConversionInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -5009,10 +6353,16 @@
void unmarshal_VkSamplerYcbcrConversionInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerYcbcrConversionInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -5020,80 +6370,130 @@
void marshal_VkBindImagePlaneMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImagePlaneMemoryInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
}
void unmarshal_VkBindImagePlaneMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindImagePlaneMemoryInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkImagePlaneMemoryRequirementsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImagePlaneMemoryRequirementsInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
}
void unmarshal_VkImagePlaneMemoryRequirementsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImagePlaneMemoryRequirementsInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->samplerYcbcrConversion, sizeof(VkBool32));
}
void marshal_VkSamplerYcbcrConversionImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
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));
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
@@ -5106,8 +6506,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
@@ -5118,17 +6520,23 @@
void marshal_VkDescriptorUpdateTemplateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
if (forMarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i)
{
- marshal_VkDescriptorUpdateTemplateEntry(vkStream, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i));
+ marshal_VkDescriptorUpdateTemplateEntry(vkStream, rootType, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i));
}
}
vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
@@ -5144,17 +6552,23 @@
void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
if (forUnmarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorUpdateEntryCount; ++i)
{
- unmarshal_VkDescriptorUpdateTemplateEntry(vkStream, (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
+ unmarshal_VkDescriptorUpdateTemplateEntry(vkStream, rootType, (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
}
}
vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
@@ -5170,8 +6584,10 @@
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));
@@ -5179,8 +6595,10 @@
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));
@@ -5188,46 +6606,76 @@
void marshal_VkPhysicalDeviceExternalImageFormatInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkExternalImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalImageFormatProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkExternalMemoryProperties(vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
}
void unmarshal_VkExternalImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalImageFormatProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
+ 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));
}
void marshal_VkPhysicalDeviceExternalBufferInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalBufferInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -5235,10 +6683,16 @@
void unmarshal_VkPhysicalDeviceExternalBufferInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalBufferInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -5246,28 +6700,46 @@
void marshal_VkExternalBufferProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalBufferProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkExternalMemoryProperties(vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
}
void unmarshal_VkExternalBufferProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalBufferProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
+ 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));
}
void marshal_VkPhysicalDeviceIDProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceIDProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint8_t*)forMarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
vkStream->write((uint8_t*)forMarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
vkStream->write((uint8_t*)forMarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
@@ -5277,10 +6749,16 @@
void unmarshal_VkPhysicalDeviceIDProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceIDProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint8_t*)forUnmarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
vkStream->read((uint8_t*)forUnmarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
vkStream->read((uint8_t*)forUnmarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
@@ -5290,82 +6768,136 @@
void marshal_VkExternalMemoryImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
}
void unmarshal_VkExternalMemoryImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalMemoryImageCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkExternalMemoryBufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryBufferCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
}
void unmarshal_VkExternalMemoryBufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalMemoryBufferCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkExportMemoryAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
}
void unmarshal_VkExportMemoryAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportMemoryAllocateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPhysicalDeviceExternalFenceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalFenceInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
void unmarshal_VkPhysicalDeviceExternalFenceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalFenceInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkExternalFenceProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalFenceProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -5373,10 +6905,16 @@
void unmarshal_VkExternalFenceProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalFenceProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -5384,64 +6922,106 @@
void marshal_VkExportFenceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportFenceCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
}
void unmarshal_VkExportFenceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportFenceCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkExportSemaphoreCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportSemaphoreCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
}
void unmarshal_VkExportSemaphoreCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportSemaphoreCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkExternalSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalSemaphoreProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -5449,10 +7029,16 @@
void unmarshal_VkExternalSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalSemaphoreProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -5460,57 +7046,93 @@
void marshal_VkPhysicalDeviceMaintenance3Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMaintenance3Properties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxPerSetDescriptors, sizeof(uint32_t));
vkStream->write((VkDeviceSize*)&forMarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
}
void unmarshal_VkPhysicalDeviceMaintenance3Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMaintenance3Properties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxPerSetDescriptors, sizeof(uint32_t));
vkStream->read((VkDeviceSize*)&forUnmarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
}
void marshal_VkDescriptorSetLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutSupport* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->supported, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceShaderDrawParametersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderDrawParametersFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDrawParameters, sizeof(VkBool32));
}
@@ -5518,10 +7140,16 @@
#ifdef VK_VERSION_1_2
void marshal_VkPhysicalDeviceVulkan11Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Features* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->storagePushConstant16, sizeof(VkBool32));
@@ -5538,10 +7166,16 @@
void unmarshal_VkPhysicalDeviceVulkan11Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkan11Features* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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->storagePushConstant16, sizeof(VkBool32));
@@ -5558,10 +7192,16 @@
void marshal_VkPhysicalDeviceVulkan11Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Properties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint8_t*)forMarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
vkStream->write((uint8_t*)forMarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
vkStream->write((uint8_t*)forMarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
@@ -5581,10 +7221,16 @@
void unmarshal_VkPhysicalDeviceVulkan11Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkan11Properties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint8_t*)forUnmarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
vkStream->read((uint8_t*)forUnmarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
vkStream->read((uint8_t*)forUnmarshaling->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
@@ -5604,10 +7250,16 @@
void marshal_VkPhysicalDeviceVulkan12Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Features* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->samplerMirrorClampToEdge, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->drawIndirectCount, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
@@ -5659,10 +7311,16 @@
void unmarshal_VkPhysicalDeviceVulkan12Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkan12Features* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -5714,8 +7372,10 @@
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));
vkStream->write((uint8_t*)&forMarshaling->subminor, sizeof(uint8_t));
@@ -5724,8 +7384,10 @@
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));
vkStream->read((uint8_t*)&forUnmarshaling->subminor, sizeof(uint8_t));
@@ -5734,14 +7396,20 @@
void marshal_VkPhysicalDeviceVulkan12Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Properties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
+ 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));
@@ -5794,14 +7462,20 @@
void unmarshal_VkPhysicalDeviceVulkan12Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkan12Properties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
+ 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));
@@ -5854,30 +7528,48 @@
void marshal_VkImageFormatListCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageFormatListCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkImageFormatListCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageFormatListCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkAttachmentDescription2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentDescription2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
@@ -5891,10 +7583,16 @@
void unmarshal_VkAttachmentDescription2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentDescription2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
@@ -5908,10 +7606,16 @@
void marshal_VkAttachmentReference2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentReference2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
vkStream->write((VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
@@ -5919,10 +7623,16 @@
void unmarshal_VkAttachmentReference2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentReference2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->attachment, sizeof(uint32_t));
vkStream->read((VkImageLayout*)&forUnmarshaling->layout, sizeof(VkImageLayout));
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
@@ -5930,10 +7640,16 @@
void marshal_VkSubpassDescription2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDescription2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
@@ -5942,7 +7658,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
{
- marshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i));
+ marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
@@ -5950,7 +7666,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
{
- marshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i));
+ marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
@@ -5962,7 +7678,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
{
- marshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i));
+ marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i));
}
}
}
@@ -5971,7 +7687,7 @@
vkStream->putBe64(cgen_var_1);
if (forMarshaling->pDepthStencilAttachment)
{
- marshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(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));
@@ -5979,10 +7695,16 @@
void unmarshal_VkSubpassDescription2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassDescription2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
@@ -5991,7 +7713,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i)
{
- unmarshal_VkAttachmentReference2(vkStream, (VkAttachmentReference2*)(forUnmarshaling->pInputAttachments + i));
+ unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pInputAttachments + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
@@ -5999,7 +7721,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
{
- unmarshal_VkAttachmentReference2(vkStream, (VkAttachmentReference2*)(forUnmarshaling->pColorAttachments + i));
+ unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
@@ -6015,7 +7737,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
{
- unmarshal_VkAttachmentReference2(vkStream, (VkAttachmentReference2*)(forUnmarshaling->pResolveAttachments + i));
+ unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pResolveAttachments + i));
}
}
}
@@ -6028,7 +7750,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilAttachment inconsistent between guest and host\n");
}
- unmarshal_VkAttachmentReference2(vkStream, (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));
@@ -6036,10 +7758,16 @@
void marshal_VkSubpassDependency2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDependency2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -6052,10 +7780,16 @@
void unmarshal_VkSubpassDependency2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassDependency2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -6068,17 +7802,23 @@
void marshal_VkRenderPassCreateInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassCreateInfo2* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
if (forMarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
{
- marshal_VkAttachmentDescription2(vkStream, (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i));
+ marshal_VkAttachmentDescription2(vkStream, rootType, (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
@@ -6086,7 +7826,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
{
- marshal_VkSubpassDescription2(vkStream, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i));
+ marshal_VkSubpassDescription2(vkStream, rootType, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
@@ -6094,7 +7834,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
{
- marshal_VkSubpassDependency2(vkStream, (const VkSubpassDependency2*)(forMarshaling->pDependencies + i));
+ marshal_VkSubpassDependency2(vkStream, rootType, (const VkSubpassDependency2*)(forMarshaling->pDependencies + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->correlatedViewMaskCount, sizeof(uint32_t));
@@ -6103,17 +7843,23 @@
void unmarshal_VkRenderPassCreateInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassCreateInfo2* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
if (forUnmarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
{
- unmarshal_VkAttachmentDescription2(vkStream, (VkAttachmentDescription2*)(forUnmarshaling->pAttachments + i));
+ unmarshal_VkAttachmentDescription2(vkStream, rootType, (VkAttachmentDescription2*)(forUnmarshaling->pAttachments + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
@@ -6121,7 +7867,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i)
{
- unmarshal_VkSubpassDescription2(vkStream, (VkSubpassDescription2*)(forUnmarshaling->pSubpasses + i));
+ unmarshal_VkSubpassDescription2(vkStream, rootType, (VkSubpassDescription2*)(forUnmarshaling->pSubpasses + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
@@ -6129,7 +7875,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i)
{
- unmarshal_VkSubpassDependency2(vkStream, (VkSubpassDependency2*)(forUnmarshaling->pDependencies + i));
+ unmarshal_VkSubpassDependency2(vkStream, rootType, (VkSubpassDependency2*)(forUnmarshaling->pDependencies + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->correlatedViewMaskCount, sizeof(uint32_t));
@@ -6138,44 +7884,74 @@
void marshal_VkSubpassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassBeginInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->storagePushConstant8, sizeof(VkBool32));
@@ -6183,10 +7959,16 @@
void unmarshal_VkPhysicalDevice8BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevice8BitStorageFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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->storagePushConstant8, sizeof(VkBool32));
@@ -6194,74 +7976,116 @@
void marshal_VkPhysicalDeviceDriverProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDriverProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
+ marshal_VkConformanceVersion(vkStream, rootType, (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
}
void unmarshal_VkPhysicalDeviceDriverProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDriverProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
+ unmarshal_VkConformanceVersion(vkStream, rootType, (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
}
void marshal_VkPhysicalDeviceShaderAtomicInt64Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderAtomicInt64Features* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceShaderFloat16Int8Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderFloat16, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderInt8, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderFloat16Int8Features* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat16, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderInt8, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceFloatControlsProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFloatControlsProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -6283,10 +8107,16 @@
void unmarshal_VkPhysicalDeviceFloatControlsProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFloatControlsProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -6308,10 +8138,16 @@
void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pBindingFlags;
@@ -6324,10 +8160,16 @@
void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetLayoutBindingFlagsCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkDescriptorBindingFlags* check_pBindingFlags;
@@ -6344,10 +8186,16 @@
void marshal_VkPhysicalDeviceDescriptorIndexingFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -6372,10 +8220,16 @@
void unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDescriptorIndexingFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -6400,10 +8254,16 @@
void marshal_VkPhysicalDeviceDescriptorIndexingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -6431,10 +8291,16 @@
void unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDescriptorIndexingProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -6462,48 +8328,78 @@
void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetVariableDescriptorCountAllocateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
}
void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetVariableDescriptorCountLayoutSupport* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
}
void marshal_VkSubpassDescriptionDepthStencilResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDescriptionDepthStencilResolve* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
// WARNING PTR CHECK
@@ -6511,16 +8407,22 @@
vkStream->putBe64(cgen_var_0);
if (forMarshaling->pDepthStencilResolveAttachment)
{
- marshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment));
+ marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment));
}
}
void unmarshal_VkSubpassDescriptionDepthStencilResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassDescriptionDepthStencilResolve* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
@@ -6532,16 +8434,22 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilResolveAttachment inconsistent between guest and host\n");
}
- unmarshal_VkAttachmentReference2(vkStream, (VkAttachmentReference2*)(forUnmarshaling->pDepthStencilResolveAttachment));
+ unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pDepthStencilResolveAttachment));
}
}
void marshal_VkPhysicalDeviceDepthStencilResolveProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->independentResolveNone, sizeof(VkBool32));
@@ -6550,10 +8458,16 @@
void unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDepthStencilResolveProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->independentResolveNone, sizeof(VkBool32));
@@ -6562,84 +8476,138 @@
void marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->scalarBlockLayout, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceScalarBlockLayoutFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkImageUsageFlags*)&forUnmarshaling->stencilUsage, sizeof(VkImageUsageFlags));
}
void marshal_VkSamplerReductionModeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerReductionModeCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSamplerReductionMode*)&forMarshaling->reductionMode, sizeof(VkSamplerReductionMode));
}
void unmarshal_VkSamplerReductionModeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerReductionModeCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->filterMinmaxImageComponentMapping, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSamplerFilterMinmaxProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -6647,10 +8615,16 @@
void unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkanMemoryModelFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -6658,28 +8632,46 @@
void marshal_VkPhysicalDeviceImagelessFramebufferFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->imagelessFramebuffer, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImagelessFramebufferFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->imagelessFramebuffer, sizeof(VkBool32));
}
void marshal_VkFramebufferAttachmentImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferAttachmentImageInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
@@ -6691,10 +8683,16 @@
void unmarshal_VkFramebufferAttachmentImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFramebufferAttachmentImageInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
@@ -6706,42 +8704,60 @@
void marshal_VkFramebufferAttachmentsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferAttachmentsCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos + i));
+ marshal_VkFramebufferAttachmentImageInfo(vkStream, rootType, (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos + i));
}
}
}
void unmarshal_VkFramebufferAttachmentsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFramebufferAttachmentsCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkFramebufferAttachmentImageInfo*)(forUnmarshaling->pAttachmentImageInfos + i));
+ unmarshal_VkFramebufferAttachmentImageInfo(vkStream, rootType, (VkFramebufferAttachmentImageInfo*)(forUnmarshaling->pAttachmentImageInfos + i));
}
}
}
void marshal_VkRenderPassAttachmentBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassAttachmentBeginInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -6754,10 +8770,16 @@
void unmarshal_VkRenderPassAttachmentBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassAttachmentBeginInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -6770,176 +8792,290 @@
void marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->uniformBufferStandardLayout, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->uniformBufferStandardLayout, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupExtendedTypes, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupExtendedTypes, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->separateDepthStencilLayouts, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->separateDepthStencilLayouts, sizeof(VkBool32));
}
void marshal_VkAttachmentReferenceStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentReferenceStencilLayout* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageLayout*)&forMarshaling->stencilLayout, sizeof(VkImageLayout));
}
void unmarshal_VkAttachmentReferenceStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentReferenceStencilLayout* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkImageLayout*)&forUnmarshaling->stencilLayout, sizeof(VkImageLayout));
}
void marshal_VkAttachmentDescriptionStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentDescriptionStencilLayout* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageLayout*)&forMarshaling->stencilInitialLayout, sizeof(VkImageLayout));
vkStream->write((VkImageLayout*)&forMarshaling->stencilFinalLayout, sizeof(VkImageLayout));
}
void unmarshal_VkAttachmentDescriptionStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentDescriptionStencilLayout* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkImageLayout*)&forUnmarshaling->stencilInitialLayout, sizeof(VkImageLayout));
vkStream->read((VkImageLayout*)&forUnmarshaling->stencilFinalLayout, sizeof(VkImageLayout));
}
void marshal_VkPhysicalDeviceHostQueryResetFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->hostQueryReset, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceHostQueryResetFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceHostQueryResetFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->hostQueryReset, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->timelineSemaphore, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTimelineSemaphoreFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->timelineSemaphore, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceTimelineSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTimelineSemaphoreProperties* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkSemaphoreTypeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreTypeCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSemaphoreType*)&forMarshaling->semaphoreType, sizeof(VkSemaphoreType));
vkStream->write((uint64_t*)&forMarshaling->initialValue, sizeof(uint64_t));
}
void unmarshal_VkSemaphoreTypeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreTypeCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkSemaphoreType*)&forUnmarshaling->semaphoreType, sizeof(VkSemaphoreType));
vkStream->read((uint64_t*)&forUnmarshaling->initialValue, sizeof(uint64_t));
}
void marshal_VkTimelineSemaphoreSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTimelineSemaphoreSubmitInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
@@ -6960,10 +9096,16 @@
void unmarshal_VkTimelineSemaphoreSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkTimelineSemaphoreSubmitInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
const uint64_t* check_pWaitSemaphoreValues;
@@ -6992,10 +9134,16 @@
void marshal_VkSemaphoreWaitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreWaitInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
@@ -7010,10 +9158,16 @@
void unmarshal_VkSemaphoreWaitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreWaitInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
@@ -7028,10 +9182,16 @@
void marshal_VkSemaphoreSignalInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreSignalInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7040,10 +9200,16 @@
void unmarshal_VkSemaphoreSignalInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreSignalInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -7052,10 +9218,16 @@
void marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddress, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
@@ -7063,10 +9235,16 @@
void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceBufferDeviceAddressFeatures* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddress, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
@@ -7074,10 +9252,16 @@
void marshal_VkBufferDeviceAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferDeviceAddressInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7085,10 +9269,16 @@
void unmarshal_VkBufferDeviceAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferDeviceAddressInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -7096,46 +9286,76 @@
void marshal_VkBufferOpaqueCaptureAddressCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint64_t*)&forMarshaling->opaqueCaptureAddress, sizeof(uint64_t));
}
void unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferOpaqueCaptureAddressCreateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint64_t*)&forUnmarshaling->opaqueCaptureAddress, sizeof(uint64_t));
}
void marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint64_t*)&forMarshaling->opaqueCaptureAddress, sizeof(uint64_t));
}
void unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryOpaqueCaptureAddressAllocateInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint64_t*)&forUnmarshaling->opaqueCaptureAddress, sizeof(uint64_t));
}
void marshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7143,10 +9363,16 @@
void unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceMemoryOpaqueCaptureAddressInfo* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -7156,13 +9382,15 @@
#ifdef VK_KHR_surface
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));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->currentExtent));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minImageExtent));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxImageExtent));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent));
+ 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));
@@ -7172,13 +9400,15 @@
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));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->currentExtent));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minImageExtent));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxImageExtent));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->currentExtent));
+ 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));
@@ -7188,16 +9418,20 @@
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)rootType;
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->colorSpace, sizeof(VkColorSpaceKHR));
}
@@ -7206,10 +9440,16 @@
#ifdef VK_KHR_swapchain
void marshal_VkSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_0, 1);
@@ -7217,7 +9457,7 @@
vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
vkStream->write((VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
vkStream->write((VkColorSpaceKHR*)&forMarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->imageExtent));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent));
vkStream->write((uint32_t*)&forMarshaling->imageArrayLayers, sizeof(uint32_t));
vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
vkStream->write((VkSharingMode*)&forMarshaling->imageSharingMode, sizeof(VkSharingMode));
@@ -7240,10 +9480,16 @@
void unmarshal_VkSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSwapchainCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7251,7 +9497,7 @@
vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->imageExtent));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->imageExtent));
vkStream->read((uint32_t*)&forUnmarshaling->imageArrayLayers, sizeof(uint32_t));
vkStream->read((VkImageUsageFlags*)&forUnmarshaling->imageUsage, sizeof(VkImageUsageFlags));
vkStream->read((VkSharingMode*)&forUnmarshaling->imageSharingMode, sizeof(VkSharingMode));
@@ -7278,10 +9524,16 @@
void marshal_VkPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -7310,10 +9562,16 @@
void unmarshal_VkPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPresentInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -7346,10 +9604,16 @@
void marshal_VkImageSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSwapchainCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7357,10 +9621,16 @@
void unmarshal_VkImageSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageSwapchainCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -7368,10 +9638,16 @@
void marshal_VkBindImageMemorySwapchainInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemorySwapchainInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7380,10 +9656,16 @@
void unmarshal_VkBindImageMemorySwapchainInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindImageMemorySwapchainInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -7392,10 +9674,16 @@
void marshal_VkAcquireNextImageInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAcquireNextImageInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7411,10 +9699,16 @@
void unmarshal_VkAcquireNextImageInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAcquireNextImageInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -7430,30 +9724,48 @@
void marshal_VkDeviceGroupPresentCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkDeviceGroupPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupPresentInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -7461,10 +9773,16 @@
void unmarshal_VkDeviceGroupPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupPresentInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -7472,19 +9790,31 @@
void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
}
void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -7492,94 +9822,120 @@
#ifdef VK_KHR_display
void marshal_VkDisplayModeParametersKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayModeParametersKHR* forMarshaling)
{
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->visibleRegion));
+ (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)
{
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->visibleRegion));
+ (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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
+ marshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
}
void unmarshal_VkDisplayModeCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayModeCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
+ unmarshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
}
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->write((uint64_t*)&cgen_var_0, 1 * 8);
- marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
+ marshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
}
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, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
+ unmarshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
}
void marshal_VkDisplayPlaneCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilitiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha, sizeof(VkDisplayPlaneAlphaFlagsKHR));
- marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->minSrcPosition));
- marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->maxSrcPosition));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minSrcExtent));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSrcExtent));
- marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->minDstPosition));
- marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->maxDstPosition));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minDstExtent));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxDstExtent));
+ marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minSrcPosition));
+ marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxSrcPosition));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minSrcExtent));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSrcExtent));
+ marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minDstPosition));
+ marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxDstPosition));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minDstExtent));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxDstExtent));
}
void unmarshal_VkDisplayPlaneCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlaneCapabilitiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkDisplayPlaneAlphaFlagsKHR*)&forUnmarshaling->supportedAlpha, sizeof(VkDisplayPlaneAlphaFlagsKHR));
- unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->minSrcPosition));
- unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->maxSrcPosition));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minSrcExtent));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxSrcExtent));
- unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->minDstPosition));
- unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->maxDstPosition));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minDstExtent));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxDstExtent));
+ unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->minSrcPosition));
+ unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->maxSrcPosition));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minSrcExtent));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxSrcExtent));
+ unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->minDstPosition));
+ unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->maxDstPosition));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minDstExtent));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxDstExtent));
}
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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7588,8 +9944,10 @@
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);
@@ -7598,14 +9956,16 @@
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);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->putString(forMarshaling->displayName);
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalDimensions));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalResolution));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->physicalDimensions));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->physicalResolution));
vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
vkStream->write((VkBool32*)&forMarshaling->planeReorderPossible, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->persistentContent, sizeof(VkBool32));
@@ -7613,14 +9973,16 @@
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->loadStringInPlace((char**)&forUnmarshaling->displayName);
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
vkStream->read((VkBool32*)&forUnmarshaling->planeReorderPossible, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->persistentContent, sizeof(VkBool32));
@@ -7628,10 +9990,16 @@
void marshal_VkDisplaySurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplaySurfaceCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_0, 1);
@@ -7641,15 +10009,21 @@
vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
vkStream->write((float*)&forMarshaling->globalAlpha, sizeof(float));
vkStream->write((VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->imageExtent));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent));
}
void unmarshal_VkDisplaySurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplaySurfaceCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7659,30 +10033,42 @@
vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
vkStream->read((float*)&forUnmarshaling->globalAlpha, sizeof(float));
vkStream->read((VkDisplayPlaneAlphaFlagBitsKHR*)&forUnmarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->imageExtent));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->imageExtent));
}
#endif
#ifdef VK_KHR_display_swapchain
void marshal_VkDisplayPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPresentInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->srcRect));
- marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->dstRect));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->srcRect));
+ marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->dstRect));
vkStream->write((VkBool32*)&forMarshaling->persistent, sizeof(VkBool32));
}
void unmarshal_VkDisplayPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPresentInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->srcRect));
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->dstRect));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->srcRect));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->dstRect));
vkStream->read((VkBool32*)&forUnmarshaling->persistent, sizeof(VkBool32));
}
@@ -7690,10 +10076,16 @@
#ifdef VK_KHR_xlib_surface
void marshal_VkXlibSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXlibSurfaceCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dpy;
@@ -7707,10 +10099,16 @@
void unmarshal_VkXlibSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkXlibSurfaceCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
Display* check_dpy;
@@ -7730,10 +10128,16 @@
#ifdef VK_KHR_xcb_surface
void marshal_VkXcbSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXcbSurfaceCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkXcbSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->connection;
@@ -7747,10 +10151,16 @@
void unmarshal_VkXcbSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkXcbSurfaceCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkXcbSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
xcb_connection_t* check_connection;
@@ -7770,10 +10180,16 @@
#ifdef VK_KHR_wayland_surface
void marshal_VkWaylandSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWaylandSurfaceCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->display;
@@ -7793,10 +10209,16 @@
void unmarshal_VkWaylandSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWaylandSurfaceCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
wl_display* check_display;
@@ -7826,10 +10248,16 @@
#ifdef VK_KHR_android_surface
void marshal_VkAndroidSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidSurfaceCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
@@ -7842,10 +10270,16 @@
void unmarshal_VkAndroidSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAndroidSurfaceCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
ANativeWindow* check_window;
@@ -7864,10 +10298,16 @@
#ifdef VK_KHR_win32_surface
void marshal_VkWin32SurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32SurfaceCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((HINSTANCE*)&forMarshaling->hinstance, sizeof(HINSTANCE));
vkStream->write((HWND*)&forMarshaling->hwnd, sizeof(HWND));
@@ -7875,10 +10315,16 @@
void unmarshal_VkWin32SurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWin32SurfaceCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((HINSTANCE*)&forUnmarshaling->hinstance, sizeof(HINSTANCE));
vkStream->read((HWND*)&forUnmarshaling->hwnd, sizeof(HWND));
@@ -7906,10 +10352,16 @@
#ifdef VK_KHR_external_memory_win32
void marshal_VkImportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
@@ -7917,10 +10369,16 @@
void unmarshal_VkImportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportMemoryWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
@@ -7928,10 +10386,16 @@
void marshal_VkExportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -7945,10 +10409,16 @@
void unmarshal_VkExportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportMemoryWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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();
@@ -7966,28 +10436,46 @@
void marshal_VkMemoryWin32HandlePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryWin32HandlePropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -7996,10 +10484,16 @@
void unmarshal_VkMemoryGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryGetWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8010,48 +10504,78 @@
#ifdef VK_KHR_external_memory_fd
void marshal_VkImportMemoryFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryFdInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((int*)&forMarshaling->fd, sizeof(int));
}
void unmarshal_VkImportMemoryFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportMemoryFdInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((int*)&forUnmarshaling->fd, sizeof(int));
}
void marshal_VkMemoryFdPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryFdPropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -8060,10 +10584,16 @@
void unmarshal_VkMemoryGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryGetFdInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8074,10 +10604,16 @@
#ifdef VK_KHR_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -8101,10 +10637,16 @@
void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -8134,10 +10676,16 @@
#ifdef VK_KHR_external_semaphore_win32
void marshal_VkImportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -8149,10 +10697,16 @@
void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8164,10 +10718,16 @@
void marshal_VkExportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -8181,10 +10741,16 @@
void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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();
@@ -8202,10 +10768,16 @@
void marshal_VkD3D12FenceSubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkD3D12FenceSubmitInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
@@ -8226,10 +10798,16 @@
void unmarshal_VkD3D12FenceSubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkD3D12FenceSubmitInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
// WARNING PTR CHECK
const uint64_t* check_pWaitSemaphoreValues;
@@ -8258,10 +10836,16 @@
void marshal_VkSemaphoreGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -8270,10 +10854,16 @@
void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8284,10 +10874,16 @@
#ifdef VK_KHR_external_semaphore_fd
void marshal_VkImportSemaphoreFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportSemaphoreFdInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -8298,10 +10894,16 @@
void unmarshal_VkImportSemaphoreFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportSemaphoreFdInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8312,10 +10914,16 @@
void marshal_VkSemaphoreGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreGetFdInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -8324,10 +10932,16 @@
void unmarshal_VkSemaphoreGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreGetFdInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8338,19 +10952,31 @@
#ifdef VK_KHR_push_descriptor
void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxPushDescriptors, sizeof(uint32_t));
}
@@ -8362,26 +10988,32 @@
#ifdef VK_KHR_incremental_present
void marshal_VkRectLayerKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRectLayerKHR* forMarshaling)
{
- marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->offset));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->extent));
+ (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)
{
- unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->offset));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->extent));
+ (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)rootType;
vkStream->write((uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
@@ -8392,7 +11024,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
{
- marshal_VkRectLayerKHR(vkStream, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i));
+ marshal_VkRectLayerKHR(vkStream, rootType, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i));
}
}
}
@@ -8400,8 +11032,10 @@
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;
@@ -8416,7 +11050,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->rectangleCount; ++i)
{
- unmarshal_VkRectLayerKHR(vkStream, (VkRectLayerKHR*)(forUnmarshaling->pRectangles + i));
+ unmarshal_VkRectLayerKHR(vkStream, rootType, (VkRectLayerKHR*)(forUnmarshaling->pRectangles + i));
}
}
}
@@ -8424,10 +11058,16 @@
void marshal_VkPresentRegionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentRegionsKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
@@ -8438,7 +11078,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
{
- marshal_VkPresentRegionKHR(vkStream, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i));
+ marshal_VkPresentRegionKHR(vkStream, rootType, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i));
}
}
}
@@ -8446,10 +11086,16 @@
void unmarshal_VkPresentRegionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPresentRegionsKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
const VkPresentRegionKHR* check_pRegions;
@@ -8464,7 +11110,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i)
{
- unmarshal_VkPresentRegionKHR(vkStream, (VkPresentRegionKHR*)(forUnmarshaling->pRegions + i));
+ unmarshal_VkPresentRegionKHR(vkStream, rootType, (VkPresentRegionKHR*)(forUnmarshaling->pRegions + i));
}
}
}
@@ -8480,19 +11126,31 @@
#ifdef VK_KHR_shared_presentable_image
void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
}
void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -8504,10 +11162,16 @@
#ifdef VK_KHR_external_fence_win32
void marshal_VkImportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportFenceWin32HandleInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -8519,10 +11183,16 @@
void unmarshal_VkImportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportFenceWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8534,10 +11204,16 @@
void marshal_VkExportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportFenceWin32HandleInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -8551,10 +11227,16 @@
void unmarshal_VkExportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportFenceWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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();
@@ -8572,10 +11254,16 @@
void marshal_VkFenceGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFenceGetWin32HandleInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -8584,10 +11272,16 @@
void unmarshal_VkFenceGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFenceGetWin32HandleInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8598,10 +11292,16 @@
#ifdef VK_KHR_external_fence_fd
void marshal_VkImportFenceFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportFenceFdInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -8612,10 +11312,16 @@
void unmarshal_VkImportFenceFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportFenceFdInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8626,10 +11332,16 @@
void marshal_VkFenceGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFenceGetFdInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -8638,10 +11350,16 @@
void unmarshal_VkFenceGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFenceGetFdInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8652,48 +11370,78 @@
#ifdef VK_KHR_performance_query
void marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePerformanceQueryFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->allowCommandBufferQueryCopies, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePerformanceQueryPropertiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -8702,10 +11450,16 @@
void unmarshal_VkPerformanceCounterKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceCounterKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -8714,10 +11468,16 @@
void marshal_VkPerformanceCounterDescriptionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceCounterDescriptionKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
@@ -8726,10 +11486,16 @@
void unmarshal_VkPerformanceCounterDescriptionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceCounterDescriptionKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((char*)forUnmarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
@@ -8738,10 +11504,16 @@
void marshal_VkQueryPoolPerformanceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -8749,10 +11521,16 @@
void unmarshal_VkQueryPoolPerformanceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueryPoolPerformanceCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -8760,53 +11538,81 @@
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)rootType;
vkStream->read((int32_t*)&forUnmarshaling->int32, sizeof(int32_t));
}
void marshal_VkAcquireProfilingLockInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAcquireProfilingLockInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
}
void unmarshal_VkAcquireProfilingLockInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAcquireProfilingLockInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
}
void marshal_VkPerformanceQuerySubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceQuerySubmitInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->counterPassIndex, sizeof(uint32_t));
}
@@ -8816,10 +11622,16 @@
#ifdef VK_KHR_get_surface_capabilities2
void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -8827,10 +11639,16 @@
void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8838,38 +11656,62 @@
void marshal_VkSurfaceCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilities2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkSurfaceCapabilitiesKHR(vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities));
}
void unmarshal_VkSurfaceCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceCapabilities2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forUnmarshaling->surfaceCapabilities));
+ 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));
}
void marshal_VkSurfaceFormat2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFormat2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkSurfaceFormatKHR(vkStream, rootType, (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat));
}
void unmarshal_VkSurfaceFormat2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceFormat2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forUnmarshaling->surfaceFormat));
+ 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));
}
#endif
@@ -8878,64 +11720,106 @@
#ifdef VK_KHR_get_display_properties2
void marshal_VkDisplayProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayProperties2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkDisplayPropertiesKHR(vkStream, rootType, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties));
}
void unmarshal_VkDisplayProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayProperties2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forUnmarshaling->displayProperties));
+ 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));
}
void marshal_VkDisplayPlaneProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneProperties2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkDisplayPlanePropertiesKHR(vkStream, rootType, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties));
}
void unmarshal_VkDisplayPlaneProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlaneProperties2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forUnmarshaling->displayPlaneProperties));
+ 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));
}
void marshal_VkDisplayModeProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayModeProperties2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkDisplayModePropertiesKHR(vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties));
}
void unmarshal_VkDisplayModeProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayModeProperties2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forUnmarshaling->displayModeProperties));
+ 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));
}
void marshal_VkDisplayPlaneInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneInfo2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -8944,10 +11828,16 @@
void unmarshal_VkDisplayPlaneInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlaneInfo2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -8956,20 +11846,32 @@
void marshal_VkDisplayPlaneCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilities2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkDisplayPlaneCapabilitiesKHR(vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities));
}
void unmarshal_VkDisplayPlaneCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlaneCapabilities2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forUnmarshaling->capabilities));
+ 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));
}
#endif
@@ -8990,10 +11892,16 @@
#ifdef VK_KHR_portability_subset
void marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->constantAlphaColorBlendFactors, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->events, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->imageViewFormatReinterpretation, sizeof(VkBool32));
@@ -9013,10 +11921,16 @@
void unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePortabilitySubsetFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->constantAlphaColorBlendFactors, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->events, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->imageViewFormatReinterpretation, sizeof(VkBool32));
@@ -9036,19 +11950,31 @@
void marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePortabilitySubsetPropertiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -9066,20 +11992,32 @@
#ifdef VK_KHR_shader_clock
void marshal_VkPhysicalDeviceShaderClockFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupClock, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderDeviceClock, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderClockFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupClock, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDeviceClock, sizeof(VkBool32));
}
@@ -9100,19 +12038,31 @@
#ifdef VK_KHR_shader_terminate_invocation
void marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderTerminateInvocation, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, sizeof(VkBool32));
}
@@ -9120,50 +12070,80 @@
#ifdef VK_KHR_fragment_shading_rate
void marshal_VkFragmentShadingRateAttachmentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
}
void unmarshal_VkFragmentShadingRateAttachmentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFragmentShadingRateAttachmentInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkAttachmentReference2(vkStream, (VkAttachmentReference2*)(forUnmarshaling->pFragmentShadingRateAttachment));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pFragmentShadingRateAttachment));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
}
void marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->fragmentSize));
+ 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));
}
void unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineFragmentShadingRateStateCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->fragmentSize));
+ 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));
}
void marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->pipelineFragmentShadingRate, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->primitiveFragmentShadingRate, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->attachmentFragmentShadingRate, sizeof(VkBool32));
@@ -9171,10 +12151,16 @@
void unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->pipelineFragmentShadingRate, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->primitiveFragmentShadingRate, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->attachmentFragmentShadingRate, sizeof(VkBool32));
@@ -9182,17 +12168,23 @@
void marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minFragmentShadingRateAttachmentTexelSize));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxFragmentShadingRateAttachmentTexelSize));
+ 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));
vkStream->write((VkBool32*)&forMarshaling->layeredShadingRateAttachments, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateNonTrivialCombinerOps, sizeof(VkBool32));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxFragmentSize));
+ 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));
@@ -9207,17 +12199,23 @@
void unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minFragmentShadingRateAttachmentTexelSize));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxFragmentShadingRateAttachmentTexelSize));
+ 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));
vkStream->read((VkBool32*)&forUnmarshaling->layeredShadingRateAttachments, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateNonTrivialCombinerOps, sizeof(VkBool32));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxFragmentSize));
+ 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));
@@ -9232,22 +12230,34 @@
void marshal_VkPhysicalDeviceFragmentShadingRateKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleCounts, sizeof(VkSampleCountFlags));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->fragmentSize));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize));
}
void unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleCounts, sizeof(VkSampleCountFlags));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->fragmentSize));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->fragmentSize));
}
#endif
@@ -9256,19 +12266,31 @@
#ifdef VK_KHR_surface_protected_capabilities
void marshal_VkSurfaceProtectedCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceProtectedCapabilitiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->supportsProtected, sizeof(VkBool32));
}
void unmarshal_VkSurfaceProtectedCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceProtectedCapabilitiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->supportsProtected, sizeof(VkBool32));
}
@@ -9284,28 +12306,46 @@
#ifdef VK_KHR_pipeline_executable_properties
void marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->pipelineExecutableInfo, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9313,10 +12353,16 @@
void unmarshal_VkPipelineInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -9324,10 +12370,16 @@
void marshal_VkPipelineExecutablePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutablePropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkShaderStageFlags*)&forMarshaling->stages, sizeof(VkShaderStageFlags));
vkStream->write((char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
@@ -9336,10 +12388,16 @@
void unmarshal_VkPipelineExecutablePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutablePropertiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stages, sizeof(VkShaderStageFlags));
vkStream->read((char*)forUnmarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
@@ -9348,10 +12406,16 @@
void marshal_VkPipelineExecutableInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9360,10 +12424,16 @@
void unmarshal_VkPipelineExecutableInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutableInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -9372,48 +12442,70 @@
void marshal_VkPipelineExecutableStatisticValueKHR(
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)
{
+ (void)rootType;
vkStream->read((VkBool32*)&forUnmarshaling->b32, sizeof(VkBool32));
}
void marshal_VkPipelineExecutableStatisticKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkPipelineExecutableStatisticValueKHR*)(&forMarshaling->value));
+ marshal_VkPipelineExecutableStatisticValueKHR(vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forMarshaling->value));
}
void unmarshal_VkPipelineExecutableStatisticKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutableStatisticKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkPipelineExecutableStatisticValueKHR*)(&forUnmarshaling->value));
+ unmarshal_VkPipelineExecutableStatisticValueKHR(vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forUnmarshaling->value));
}
void marshal_VkPipelineExecutableInternalRepresentationKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->isText, sizeof(VkBool32));
@@ -9430,10 +12522,16 @@
void unmarshal_VkPipelineExecutableInternalRepresentationKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutableInternalRepresentationKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->isText, sizeof(VkBool32));
@@ -9455,10 +12553,16 @@
#ifdef VK_KHR_pipeline_library
void marshal_VkPipelineLibraryCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineLibraryCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -9471,10 +12575,16 @@
void unmarshal_VkPipelineLibraryCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineLibraryCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -9491,10 +12601,16 @@
#ifdef VK_KHR_copy_commands2
void marshal_VkBufferCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferCopy2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
@@ -9502,10 +12618,16 @@
void unmarshal_VkBufferCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferCopy2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDeviceSize*)&forUnmarshaling->srcOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->dstOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
@@ -9513,10 +12635,16 @@
void marshal_VkCopyBufferInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyBufferInfo2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9528,17 +12656,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- marshal_VkBufferCopy2KHR(vkStream, (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i));
+ marshal_VkBufferCopy2KHR(vkStream, rootType, (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i));
}
}
}
void unmarshal_VkCopyBufferInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyBufferInfo2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -9550,43 +12684,61 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
{
- unmarshal_VkBufferCopy2KHR(vkStream, (VkBufferCopy2KHR*)(forUnmarshaling->pRegions + i));
+ unmarshal_VkBufferCopy2KHR(vkStream, rootType, (VkBufferCopy2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
void marshal_VkImageCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageCopy2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset));
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+ 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_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->srcOffset));
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->dstOffset));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+ 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_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9600,17 +12752,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- marshal_VkImageCopy2KHR(vkStream, (const VkImageCopy2KHR*)(forMarshaling->pRegions + i));
+ marshal_VkImageCopy2KHR(vkStream, rootType, (const VkImageCopy2KHR*)(forMarshaling->pRegions + i));
}
}
}
void unmarshal_VkCopyImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyImageInfo2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -9624,45 +12782,63 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
{
- unmarshal_VkImageCopy2KHR(vkStream, (VkImageCopy2KHR*)(forUnmarshaling->pRegions + i));
+ unmarshal_VkImageCopy2KHR(vkStream, rootType, (VkImageCopy2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
void marshal_VkBufferImageCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferImageCopy2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->imageOffset));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->imageExtent));
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->imageOffset));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9675,17 +12851,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- marshal_VkBufferImageCopy2KHR(vkStream, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
+ marshal_VkBufferImageCopy2KHR(vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
}
}
}
void unmarshal_VkCopyBufferToImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyBufferToImageInfo2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -9698,17 +12880,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
{
- unmarshal_VkBufferImageCopy2KHR(vkStream, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
+ unmarshal_VkBufferImageCopy2KHR(vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
void marshal_VkCopyImageToBufferInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyImageToBufferInfo2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9721,17 +12909,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- marshal_VkBufferImageCopy2KHR(vkStream, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
+ marshal_VkBufferImageCopy2KHR(vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
}
}
}
void unmarshal_VkCopyImageToBufferInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyImageToBufferInfo2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -9744,53 +12938,71 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
{
- unmarshal_VkBufferImageCopy2KHR(vkStream, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
+ unmarshal_VkBufferImageCopy2KHR(vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
void marshal_VkImageBlit2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageBlit2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
{
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->srcOffsets + i));
+ rootType = forMarshaling->sType;
}
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ 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_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->dstOffsets + 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_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i));
}
}
void unmarshal_VkImageBlit2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageBlit2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
{
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
+ rootType = forUnmarshaling->sType;
}
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ 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_VkOffset3D(vkStream, (VkOffset3D*)(forUnmarshaling->dstOffsets + 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_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
}
}
void marshal_VkBlitImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBlitImageInfo2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9804,7 +13016,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- marshal_VkImageBlit2KHR(vkStream, (const VkImageBlit2KHR*)(forMarshaling->pRegions + i));
+ marshal_VkImageBlit2KHR(vkStream, rootType, (const VkImageBlit2KHR*)(forMarshaling->pRegions + i));
}
}
vkStream->write((VkFilter*)&forMarshaling->filter, sizeof(VkFilter));
@@ -9812,10 +13024,16 @@
void unmarshal_VkBlitImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBlitImageInfo2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -9829,7 +13047,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
{
- unmarshal_VkImageBlit2KHR(vkStream, (VkImageBlit2KHR*)(forUnmarshaling->pRegions + i));
+ unmarshal_VkImageBlit2KHR(vkStream, rootType, (VkImageBlit2KHR*)(forUnmarshaling->pRegions + i));
}
}
vkStream->read((VkFilter*)&forUnmarshaling->filter, sizeof(VkFilter));
@@ -9837,36 +13055,54 @@
void marshal_VkImageResolve2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageResolve2KHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset));
- marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
- marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset));
- marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+ 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_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->srcOffset));
- unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
- unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->dstOffset));
- unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+ 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_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9880,17 +13116,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- marshal_VkImageResolve2KHR(vkStream, (const VkImageResolve2KHR*)(forMarshaling->pRegions + i));
+ marshal_VkImageResolve2KHR(vkStream, rootType, (const VkImageResolve2KHR*)(forMarshaling->pRegions + i));
}
}
}
void unmarshal_VkResolveImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkResolveImageInfo2KHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -9904,7 +13146,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
{
- unmarshal_VkImageResolve2KHR(vkStream, (VkImageResolve2KHR*)(forUnmarshaling->pRegions + i));
+ unmarshal_VkImageResolve2KHR(vkStream, rootType, (VkImageResolve2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
@@ -9913,10 +13155,16 @@
#ifdef VK_ANDROID_native_buffer
void marshal_VkNativeBufferANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkNativeBufferANDROID* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -9933,10 +13181,16 @@
void unmarshal_VkNativeBufferANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkNativeBufferANDROID* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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();
@@ -9959,10 +13213,16 @@
#ifdef VK_EXT_debug_report
void marshal_VkDebugReportCallbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugReportCallbackCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnCallback;
vkStream->putBe64(cgen_var_0);
@@ -9977,10 +13237,16 @@
void unmarshal_VkDebugReportCallbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugReportCallbackCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDebugReportFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugReportFlagsEXT));
forUnmarshaling->pfnCallback = (PFN_vkDebugReportCallbackEXT)vkStream->getBe64();
// WARNING PTR CHECK
@@ -10006,19 +13272,31 @@
#ifdef VK_AMD_rasterization_order
void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
}
void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -10030,10 +13308,16 @@
#ifdef VK_EXT_debug_marker
void marshal_VkDebugMarkerObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerObjectNameInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
vkStream->putString(forMarshaling->pObjectName);
@@ -10041,10 +13325,16 @@
void unmarshal_VkDebugMarkerObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugMarkerObjectNameInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
@@ -10052,10 +13342,16 @@
void marshal_VkDebugMarkerObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerObjectTagInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
@@ -10066,10 +13362,16 @@
void unmarshal_VkDebugMarkerObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugMarkerObjectTagInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
vkStream->read((uint64_t*)&forUnmarshaling->tagName, sizeof(uint64_t));
@@ -10079,20 +13381,32 @@
void marshal_VkDebugMarkerMarkerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerMarkerInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->putString(forMarshaling->pMarkerName);
vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
}
void unmarshal_VkDebugMarkerMarkerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugMarkerMarkerInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->loadStringInPlace((char**)&forUnmarshaling->pMarkerName);
vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
}
@@ -10103,46 +13417,76 @@
#ifdef VK_NV_dedicated_allocation
void marshal_VkDedicatedAllocationImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationImageCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
}
void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
}
void marshal_VkDedicatedAllocationBufferCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
}
void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
}
void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -10153,10 +13497,16 @@
void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -10169,30 +13519,48 @@
#ifdef VK_EXT_transform_feedback
void marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->transformFeedback, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->geometryStreams, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTransformFeedbackFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->transformFeedback, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->geometryStreams, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -10207,10 +13575,16 @@
void unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTransformFeedbackPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -10225,20 +13599,32 @@
void marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->rasterizationStream, sizeof(uint32_t));
}
void unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationStateStreamCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->rasterizationStream, sizeof(uint32_t));
}
@@ -10247,10 +13633,16 @@
#ifdef VK_NVX_image_view_handle
void marshal_VkImageViewHandleInfoNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewHandleInfoNVX* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -10262,10 +13654,16 @@
void unmarshal_VkImageViewHandleInfoNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageViewHandleInfoNVX* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -10277,20 +13675,32 @@
void marshal_VkImageViewAddressPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewAddressPropertiesNVX* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
void unmarshal_VkImageViewAddressPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageViewAddressPropertiesNVX* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
@@ -10307,19 +13717,31 @@
#ifdef VK_AMD_texture_gather_bias_lod
void marshal_VkTextureLODGatherFormatPropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
}
void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
}
@@ -10327,8 +13749,10 @@
#ifdef VK_AMD_shader_info
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));
vkStream->write((uint32_t*)&forMarshaling->ldsSizePerLocalWorkGroup, sizeof(uint32_t));
@@ -10340,8 +13764,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->ldsSizePerLocalWorkGroup, sizeof(uint32_t));
@@ -10351,10 +13777,12 @@
void marshal_VkShaderStatisticsInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkShaderStatisticsInfoAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkShaderStageFlags*)&forMarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
- marshal_VkShaderResourceUsageAMD(vkStream, (VkShaderResourceUsageAMD*)(&forMarshaling->resourceUsage));
+ 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));
@@ -10364,10 +13792,12 @@
void unmarshal_VkShaderStatisticsInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkShaderStatisticsInfoAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkShaderStageFlags*)&forUnmarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
- unmarshal_VkShaderResourceUsageAMD(vkStream, (VkShaderResourceUsageAMD*)(&forUnmarshaling->resourceUsage));
+ 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));
@@ -10381,20 +13811,32 @@
#ifdef VK_GGP_stream_descriptor_surface
void marshal_VkStreamDescriptorSurfaceCreateInfoGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkStreamDescriptorSurfaceCreateInfoGGP* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -10403,19 +13845,31 @@
#ifdef VK_NV_corner_sampled_image
void marshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->cornerSampledImage, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCornerSampledImageFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->cornerSampledImage, sizeof(VkBool32));
}
@@ -10425,9 +13879,11 @@
#ifdef VK_NV_external_memory_capabilities
void marshal_VkExternalImageFormatPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalImageFormatPropertiesNV* forMarshaling)
{
- marshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
+ (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));
@@ -10435,9 +13891,11 @@
void unmarshal_VkExternalImageFormatPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalImageFormatPropertiesNV* forUnmarshaling)
{
- unmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
+ (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));
@@ -10447,37 +13905,61 @@
#ifdef VK_NV_external_memory
void marshal_VkExternalMemoryImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
}
void unmarshal_VkExternalMemoryImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalMemoryImageCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkExportMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
}
void unmarshal_VkExportMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportMemoryAllocateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -10485,30 +13967,48 @@
#ifdef VK_NV_external_memory_win32
void marshal_VkImportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
}
void unmarshal_VkImportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportMemoryWin32HandleInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
}
void marshal_VkExportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -10521,10 +14021,16 @@
void unmarshal_VkExportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportMemoryWin32HandleInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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();
@@ -10543,10 +14049,16 @@
#ifdef VK_NV_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -10570,10 +14082,16 @@
void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -10599,20 +14117,32 @@
#ifdef VK_EXT_validation_flags
void marshal_VkValidationFlagsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationFlagsEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkValidationFlagsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkValidationFlagsEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -10621,10 +14151,16 @@
#ifdef VK_NN_vi_surface
void marshal_VkViSurfaceCreateInfoNN(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkViSurfaceCreateInfoNN* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
@@ -10637,10 +14173,16 @@
void unmarshal_VkViSurfaceCreateInfoNN(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkViSurfaceCreateInfoNN* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
void* check_window;
@@ -10663,19 +14205,31 @@
#ifdef VK_EXT_texture_compression_astc_hdr
void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
}
@@ -10683,37 +14237,61 @@
#ifdef VK_EXT_astc_decode_mode
void marshal_VkImageViewASTCDecodeModeEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewASTCDecodeModeEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkFormat*)&forUnmarshaling->decodeMode, sizeof(VkFormat));
}
void marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->decodeModeSharedExponent, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->decodeModeSharedExponent, sizeof(VkBool32));
}
@@ -10721,10 +14299,16 @@
#ifdef VK_EXT_conditional_rendering
void marshal_VkConditionalRenderingBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkConditionalRenderingBeginInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -10734,10 +14318,16 @@
void unmarshal_VkConditionalRenderingBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkConditionalRenderingBeginInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -10747,39 +14337,63 @@
void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->conditionalRendering, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->inheritedConditionalRendering, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->conditionalRendering, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->inheritedConditionalRendering, sizeof(VkBool32));
}
void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->conditionalRenderingEnable, sizeof(VkBool32));
}
void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->conditionalRenderingEnable, sizeof(VkBool32));
}
@@ -10787,26 +14401,36 @@
#ifdef VK_NV_clip_space_w_scaling
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)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)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -10818,7 +14442,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
{
- marshal_VkViewportWScalingNV(vkStream, (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i));
+ marshal_VkViewportWScalingNV(vkStream, rootType, (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i));
}
}
}
@@ -10826,10 +14450,16 @@
void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->viewportWScalingEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -10845,7 +14475,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
{
- unmarshal_VkViewportWScalingNV(vkStream, (VkViewportWScalingNV*)(forUnmarshaling->pViewportWScalings + i));
+ unmarshal_VkViewportWScalingNV(vkStream, rootType, (VkViewportWScalingNV*)(forUnmarshaling->pViewportWScalings + i));
}
}
}
@@ -10859,15 +14489,21 @@
#ifdef VK_EXT_display_surface_counter
void marshal_VkSurfaceCapabilities2EXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilities2EXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->currentExtent));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minImageExtent));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxImageExtent));
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent));
+ 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));
@@ -10878,15 +14514,21 @@
void unmarshal_VkSurfaceCapabilities2EXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceCapabilities2EXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxImageCount, sizeof(uint32_t));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->currentExtent));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->minImageExtent));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxImageExtent));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->currentExtent));
+ 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));
@@ -10899,73 +14541,121 @@
#ifdef VK_EXT_display_control
void marshal_VkDisplayPowerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPowerInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDisplayPowerStateEXT*)&forMarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
}
void unmarshal_VkDisplayPowerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPowerInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkDeviceEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceEventInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
}
void unmarshal_VkDeviceEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceEventInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkDisplayEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayEventInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDisplayEventTypeEXT*)&forMarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
}
void unmarshal_VkDisplayEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayEventInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkSwapchainCounterCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainCounterCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
}
void unmarshal_VkSwapchainCounterCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSwapchainCounterCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -10973,22 +14663,28 @@
#ifdef VK_GOOGLE_display_timing
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)rootType;
vkStream->read((uint64_t*)&forUnmarshaling->refreshDuration, sizeof(uint64_t));
}
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));
vkStream->write((uint64_t*)&forMarshaling->actualPresentTime, sizeof(uint64_t));
@@ -10998,8 +14694,10 @@
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));
vkStream->read((uint64_t*)&forUnmarshaling->actualPresentTime, sizeof(uint64_t));
@@ -11009,26 +14707,36 @@
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)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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
@@ -11039,7 +14747,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
{
- marshal_VkPresentTimeGOOGLE(vkStream, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i));
+ marshal_VkPresentTimeGOOGLE(vkStream, rootType, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i));
}
}
}
@@ -11047,10 +14755,16 @@
void unmarshal_VkPresentTimesInfoGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPresentTimesInfoGOOGLE* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
const VkPresentTimeGOOGLE* check_pTimes;
@@ -11065,7 +14779,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i)
{
- unmarshal_VkPresentTimeGOOGLE(vkStream, (VkPresentTimeGOOGLE*)(forUnmarshaling->pTimes + i));
+ unmarshal_VkPresentTimeGOOGLE(vkStream, rootType, (VkPresentTimeGOOGLE*)(forUnmarshaling->pTimes + i));
}
}
}
@@ -11081,19 +14795,31 @@
#ifdef VK_NVX_multiview_per_view_attributes
void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->perViewPositionAllComponents, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->perViewPositionAllComponents, sizeof(VkBool32));
}
@@ -11101,8 +14827,10 @@
#ifdef VK_NV_viewport_swizzle
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));
@@ -11111,8 +14839,10 @@
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));
@@ -11121,10 +14851,16 @@
void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -11136,7 +14872,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
{
- marshal_VkViewportSwizzleNV(vkStream, (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
+ marshal_VkViewportSwizzleNV(vkStream, rootType, (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
}
}
}
@@ -11144,10 +14880,16 @@
void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -11163,7 +14905,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
{
- unmarshal_VkViewportSwizzleNV(vkStream, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
+ unmarshal_VkViewportSwizzleNV(vkStream, rootType, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
}
}
}
@@ -11173,28 +14915,46 @@
#ifdef VK_EXT_discard_rectangles
void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxDiscardRectangles, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxDiscardRectangles, sizeof(uint32_t));
}
void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
@@ -11207,7 +14967,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
{
- marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pDiscardRectangles + i));
+ marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pDiscardRectangles + i));
}
}
}
@@ -11215,10 +14975,16 @@
void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->discardRectangleCount, sizeof(uint32_t));
@@ -11235,7 +15001,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->discardRectangleCount; ++i)
{
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pDiscardRectangles + i));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pDiscardRectangles + i));
}
}
}
@@ -11245,10 +15011,16 @@
#ifdef VK_EXT_conservative_rasterization
void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -11262,10 +15034,16 @@
void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -11279,10 +15057,16 @@
void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((float*)&forMarshaling->extraPrimitiveOverestimationSize, sizeof(float));
@@ -11290,10 +15074,16 @@
void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((float*)&forUnmarshaling->extraPrimitiveOverestimationSize, sizeof(float));
@@ -11303,38 +15093,62 @@
#ifdef VK_EXT_depth_clip_enable
void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
}
void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
}
void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
}
@@ -11345,30 +15159,40 @@
#ifdef VK_EXT_hdr_metadata
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)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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed));
- marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen));
- marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue));
- marshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->whitePoint));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed));
+ marshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen));
+ marshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue));
+ marshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->whitePoint));
vkStream->write((float*)&forMarshaling->maxLuminance, sizeof(float));
vkStream->write((float*)&forMarshaling->minLuminance, sizeof(float));
vkStream->write((float*)&forMarshaling->maxContentLightLevel, sizeof(float));
@@ -11377,14 +15201,20 @@
void unmarshal_VkHdrMetadataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkHdrMetadataEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryRed));
- unmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryGreen));
- unmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryBlue));
- unmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forUnmarshaling->whitePoint));
+ 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->whitePoint));
vkStream->read((float*)&forUnmarshaling->maxLuminance, sizeof(float));
vkStream->read((float*)&forUnmarshaling->minLuminance, sizeof(float));
vkStream->read((float*)&forUnmarshaling->maxContentLightLevel, sizeof(float));
@@ -11395,10 +15225,16 @@
#ifdef VK_MVK_ios_surface
void marshal_VkIOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIOSSurfaceCreateInfoMVK* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
@@ -11411,10 +15247,16 @@
void unmarshal_VkIOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkIOSSurfaceCreateInfoMVK* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
const void* check_pView;
@@ -11433,10 +15275,16 @@
#ifdef VK_MVK_macos_surface
void marshal_VkMacOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMacOSSurfaceCreateInfoMVK* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
@@ -11449,10 +15297,16 @@
void unmarshal_VkMacOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMacOSSurfaceCreateInfoMVK* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
const void* check_pView;
@@ -11477,30 +15331,48 @@
#ifdef VK_EXT_debug_utils
void marshal_VkDebugUtilsLabelEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsLabelEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->putString(forMarshaling->pLabelName);
vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
}
void unmarshal_VkDebugUtilsLabelEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsLabelEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->loadStringInPlace((char**)&forUnmarshaling->pLabelName);
vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
}
void marshal_VkDebugUtilsObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsObjectNameInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
@@ -11521,10 +15393,16 @@
void unmarshal_VkDebugUtilsObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsObjectNameInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
@@ -11549,10 +15427,16 @@
void marshal_VkDebugUtilsMessengerCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)
{
@@ -11580,7 +15464,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
{
- marshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
+ marshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
}
}
}
@@ -11594,7 +15478,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
{
- marshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
+ marshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
}
}
}
@@ -11608,7 +15492,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
{
- marshal_VkDebugUtilsObjectNameInfoEXT(vkStream, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
+ marshal_VkDebugUtilsObjectNameInfoEXT(vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
}
}
}
@@ -11616,10 +15500,16 @@
void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)
{
@@ -11655,7 +15545,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i)
{
- unmarshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
+ unmarshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
}
}
}
@@ -11673,7 +15563,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i)
{
- unmarshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
+ unmarshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
}
}
}
@@ -11691,7 +15581,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i)
{
- unmarshal_VkDebugUtilsObjectNameInfoEXT(vkStream, (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
+ unmarshal_VkDebugUtilsObjectNameInfoEXT(vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
}
}
}
@@ -11699,10 +15589,16 @@
void marshal_VkDebugUtilsMessengerCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -11719,10 +15615,16 @@
void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -11742,10 +15644,16 @@
void marshal_VkDebugUtilsObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsObjectTagInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
@@ -11756,10 +15664,16 @@
void unmarshal_VkDebugUtilsObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsObjectTagInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
vkStream->read((uint64_t*)&forUnmarshaling->tagName, sizeof(uint64_t));
@@ -11771,52 +15685,82 @@
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void marshal_VkAndroidHardwareBufferUsageANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferUsageANDROID* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint64_t*)&forMarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
}
void unmarshal_VkAndroidHardwareBufferUsageANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAndroidHardwareBufferUsageANDROID* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint64_t*)&forUnmarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
}
void marshal_VkAndroidHardwareBufferPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}
void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}
void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
+ 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));
@@ -11825,14 +15769,20 @@
void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
+ 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));
@@ -11841,28 +15791,46 @@
void marshal_VkImportAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((AHardwareBuffer*)forMarshaling->buffer, sizeof(AHardwareBuffer));
}
void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((AHardwareBuffer*)forUnmarshaling->buffer, sizeof(AHardwareBuffer));
}
void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -11870,10 +15838,16 @@
void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -11881,19 +15855,31 @@
void marshal_VkExternalFormatANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalFormatANDROID* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
}
@@ -11909,30 +15895,48 @@
#ifdef VK_EXT_inline_uniform_block
void marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -11942,10 +15946,16 @@
void unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -11955,39 +15965,63 @@
void marshal_VkWriteDescriptorSetInlineUniformBlockEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
}
void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
}
@@ -11997,100 +16031,130 @@
#ifdef VK_EXT_sample_locations
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)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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSampleCountFlagBits*)&forMarshaling->sampleLocationsPerPixel, sizeof(VkSampleCountFlagBits));
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->sampleLocationGridSize));
+ 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, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i));
+ marshal_VkSampleLocationEXT(vkStream, rootType, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i));
}
}
}
void unmarshal_VkSampleLocationsInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSampleLocationsInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkExtent2D*)(&forUnmarshaling->sampleLocationGridSize));
+ 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, (VkSampleLocationEXT*)(forUnmarshaling->pSampleLocations + i));
+ unmarshal_VkSampleLocationEXT(vkStream, rootType, (VkSampleLocationEXT*)(forUnmarshaling->pSampleLocations + i));
}
}
}
void marshal_VkAttachmentSampleLocationsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentSampleLocationsEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((uint32_t*)&forMarshaling->attachmentIndex, sizeof(uint32_t));
- marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+ marshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}
void unmarshal_VkAttachmentSampleLocationsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentSampleLocationsEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->attachmentIndex, sizeof(uint32_t));
- unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+ unmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}
void marshal_VkSubpassSampleLocationsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassSampleLocationsEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((uint32_t*)&forMarshaling->subpassIndex, sizeof(uint32_t));
- marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+ marshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}
void unmarshal_VkSubpassSampleLocationsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassSampleLocationsEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->subpassIndex, sizeof(uint32_t));
- unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+ unmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}
void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkAttachmentSampleLocationsEXT*)(forMarshaling->pAttachmentInitialSampleLocations + i));
+ marshal_VkAttachmentSampleLocationsEXT(vkStream, rootType, (const VkAttachmentSampleLocationsEXT*)(forMarshaling->pAttachmentInitialSampleLocations + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
@@ -12098,23 +16162,29 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->postSubpassSampleLocationsCount; ++i)
{
- marshal_VkSubpassSampleLocationsEXT(vkStream, (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i));
+ marshal_VkSubpassSampleLocationsEXT(vkStream, rootType, (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i));
}
}
}
void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkAttachmentSampleLocationsEXT*)(forUnmarshaling->pAttachmentInitialSampleLocations + i));
+ unmarshal_VkAttachmentSampleLocationsEXT(vkStream, rootType, (VkAttachmentSampleLocationsEXT*)(forUnmarshaling->pAttachmentInitialSampleLocations + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
@@ -12122,39 +16192,57 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->postSubpassSampleLocationsCount; ++i)
{
- unmarshal_VkSubpassSampleLocationsEXT(vkStream, (VkSubpassSampleLocationsEXT*)(forUnmarshaling->pPostSubpassSampleLocations + i));
+ unmarshal_VkSubpassSampleLocationsEXT(vkStream, rootType, (VkSubpassSampleLocationsEXT*)(forUnmarshaling->pPostSubpassSampleLocations + i));
}
}
}
void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+ marshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}
void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+ unmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}
void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
+ 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));
@@ -12162,12 +16250,18 @@
void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
+ 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));
@@ -12175,48 +16269,78 @@
void marshal_VkMultisamplePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMultisamplePropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
}
void unmarshal_VkMultisamplePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMultisamplePropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
+ 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));
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -12227,10 +16351,16 @@
void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -12241,10 +16371,16 @@
void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->srcPremultiplied, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->dstPremultiplied, sizeof(VkBool32));
vkStream->write((VkBlendOverlapEXT*)&forMarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
@@ -12252,10 +16388,16 @@
void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->srcPremultiplied, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->dstPremultiplied, sizeof(VkBool32));
vkStream->read((VkBlendOverlapEXT*)&forUnmarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
@@ -12265,10 +16407,16 @@
#ifdef VK_NV_fragment_coverage_to_color
void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->coverageToColorEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->coverageToColorLocation, sizeof(uint32_t));
@@ -12276,10 +16424,16 @@
void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->coverageToColorEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->coverageToColorLocation, sizeof(uint32_t));
@@ -12289,10 +16443,16 @@
#ifdef VK_NV_framebuffer_mixed_samples
void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
@@ -12308,10 +16468,16 @@
void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->coverageModulationTableEnable, sizeof(VkBool32));
@@ -12335,39 +16501,63 @@
#ifdef VK_NV_shader_sm_builtins
void marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->shaderSMCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->shaderWarpsPerSM, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->shaderSMCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->shaderWarpsPerSM, sizeof(uint32_t));
}
void marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderSMBuiltins, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderSMBuiltins, sizeof(VkBool32));
}
@@ -12377,8 +16567,10 @@
#ifdef VK_EXT_image_drm_format_modifier
void marshal_VkDrmFormatModifierPropertiesEXT(
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));
@@ -12386,8 +16578,10 @@
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));
@@ -12395,10 +16589,16 @@
void marshal_VkDrmFormatModifierPropertiesListEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesListEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDrmFormatModifierProperties;
@@ -12409,7 +16609,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i)
{
- marshal_VkDrmFormatModifierPropertiesEXT(vkStream, (VkDrmFormatModifierPropertiesEXT*)(forMarshaling->pDrmFormatModifierProperties + i));
+ marshal_VkDrmFormatModifierPropertiesEXT(vkStream, rootType, (VkDrmFormatModifierPropertiesEXT*)(forMarshaling->pDrmFormatModifierProperties + i));
}
}
}
@@ -12417,10 +16617,16 @@
void unmarshal_VkDrmFormatModifierPropertiesListEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDrmFormatModifierPropertiesListEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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;
@@ -12435,7 +16641,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierCount; ++i)
{
- unmarshal_VkDrmFormatModifierPropertiesEXT(vkStream, (VkDrmFormatModifierPropertiesEXT*)(forUnmarshaling->pDrmFormatModifierProperties + i));
+ unmarshal_VkDrmFormatModifierPropertiesEXT(vkStream, rootType, (VkDrmFormatModifierPropertiesEXT*)(forUnmarshaling->pDrmFormatModifierProperties + i));
}
}
}
@@ -12443,10 +16649,16 @@
void marshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
@@ -12461,10 +16673,16 @@
void unmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
@@ -12483,73 +16701,109 @@
void marshal_VkImageDrmFormatModifierListCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageDrmFormatModifierListCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i));
+ marshal_VkSubresourceLayout(vkStream, rootType, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i));
}
}
}
void unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageDrmFormatModifierExplicitCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkSubresourceLayout*)(forUnmarshaling->pPlaneLayouts + i));
+ unmarshal_VkSubresourceLayout(vkStream, rootType, (VkSubresourceLayout*)(forUnmarshaling->pPlaneLayouts + i));
}
}
}
void marshal_VkImageDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkImageDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageDrmFormatModifierPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -12557,10 +16811,16 @@
#ifdef VK_EXT_validation_cache
void marshal_VkValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationCacheCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
vkStream->putBe64(cgen_var_0);
@@ -12569,10 +16829,16 @@
void unmarshal_VkValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkValidationCacheCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
@@ -12580,10 +16846,16 @@
void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -12591,10 +16863,16 @@
void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -12608,26 +16886,36 @@
#ifdef VK_NV_shading_rate_image
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));
}
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));
}
void marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shadingRateImageEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -12639,7 +16927,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
{
- marshal_VkShadingRatePaletteNV(vkStream, (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i));
+ marshal_VkShadingRatePaletteNV(vkStream, rootType, (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i));
}
}
}
@@ -12647,10 +16935,16 @@
void unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportShadingRateImageStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shadingRateImageEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -12666,7 +16960,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
{
- unmarshal_VkShadingRatePaletteNV(vkStream, (VkShadingRatePaletteNV*)(forUnmarshaling->pShadingRatePalettes + i));
+ unmarshal_VkShadingRatePaletteNV(vkStream, rootType, (VkShadingRatePaletteNV*)(forUnmarshaling->pShadingRatePalettes + i));
}
}
}
@@ -12674,50 +16968,76 @@
void marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shadingRateImage, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shadingRateCoarseSampleOrder, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShadingRateImageFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shadingRateImage, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shadingRateCoarseSampleOrder, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->shadingRateTexelSize));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateTexelSize));
vkStream->write((uint32_t*)&forMarshaling->shadingRatePaletteSize, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->shadingRateMaxCoarseSamples, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShadingRateImagePropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->shadingRateTexelSize));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->shadingRateTexelSize));
vkStream->read((uint32_t*)&forUnmarshaling->shadingRatePaletteSize, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->shadingRateMaxCoarseSamples, sizeof(uint32_t));
}
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));
@@ -12725,8 +17045,10 @@
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));
@@ -12734,8 +17056,10 @@
void marshal_VkCoarseSampleOrderCustomNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCoarseSampleOrderCustomNV* forMarshaling)
{
+ (void)rootType;
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));
@@ -12743,15 +17067,17 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationCount; ++i)
{
- marshal_VkCoarseSampleLocationNV(vkStream, (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i));
+ marshal_VkCoarseSampleLocationNV(vkStream, rootType, (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i));
}
}
}
void unmarshal_VkCoarseSampleOrderCustomNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCoarseSampleOrderCustomNV* forUnmarshaling)
{
+ (void)rootType;
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));
@@ -12759,41 +17085,53 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationCount; ++i)
{
- unmarshal_VkCoarseSampleLocationNV(vkStream, (VkCoarseSampleLocationNV*)(forUnmarshaling->pSampleLocations + i));
+ unmarshal_VkCoarseSampleLocationNV(vkStream, rootType, (VkCoarseSampleLocationNV*)(forUnmarshaling->pSampleLocations + i));
}
}
}
void marshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->customSampleOrderCount, sizeof(uint32_t));
if (forMarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->customSampleOrderCount; ++i)
{
- marshal_VkCoarseSampleOrderCustomNV(vkStream, (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i));
+ marshal_VkCoarseSampleOrderCustomNV(vkStream, rootType, (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i));
}
}
}
void unmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->customSampleOrderCount, sizeof(uint32_t));
if (forUnmarshaling)
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->customSampleOrderCount; ++i)
{
- unmarshal_VkCoarseSampleOrderCustomNV(vkStream, (VkCoarseSampleOrderCustomNV*)(forUnmarshaling->pCustomSampleOrders + i));
+ unmarshal_VkCoarseSampleOrderCustomNV(vkStream, rootType, (VkCoarseSampleOrderCustomNV*)(forUnmarshaling->pCustomSampleOrders + i));
}
}
}
@@ -12802,10 +17140,16 @@
#ifdef VK_NV_ray_tracing
void marshal_VkRayTracingShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->closestHitShader, sizeof(uint32_t));
@@ -12815,10 +17159,16 @@
void unmarshal_VkRayTracingShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingShaderGroupCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->generalShader, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->closestHitShader, sizeof(uint32_t));
@@ -12828,17 +17178,23 @@
void marshal_VkRayTracingPipelineCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
@@ -12846,7 +17202,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i)
{
- marshal_VkRayTracingShaderGroupCreateInfoNV(vkStream, (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
+ marshal_VkRayTracingShaderGroupCreateInfoNV(vkStream, rootType, (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->maxRecursionDepth, sizeof(uint32_t));
@@ -12861,17 +17217,23 @@
void unmarshal_VkRayTracingPipelineCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingPipelineCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
@@ -12879,7 +17241,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i)
{
- unmarshal_VkRayTracingShaderGroupCreateInfoNV(vkStream, (VkRayTracingShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
+ unmarshal_VkRayTracingShaderGroupCreateInfoNV(vkStream, rootType, (VkRayTracingShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->maxRecursionDepth, sizeof(uint32_t));
@@ -12894,10 +17256,16 @@
void marshal_VkGeometryTrianglesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryTrianglesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkBuffer_u64(&forMarshaling->vertexData, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -12919,10 +17287,16 @@
void unmarshal_VkGeometryTrianglesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeometryTrianglesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -12944,10 +17318,16 @@
void marshal_VkGeometryAABBNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryAABBNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkBuffer_u64(&forMarshaling->aabbData, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -12958,10 +17338,16 @@
void unmarshal_VkGeometryAABBNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeometryAABBNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -12972,48 +17358,70 @@
void marshal_VkGeometryDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryDataNV* forMarshaling)
{
- marshal_VkGeometryTrianglesNV(vkStream, (VkGeometryTrianglesNV*)(&forMarshaling->triangles));
- marshal_VkGeometryAABBNV(vkStream, (VkGeometryAABBNV*)(&forMarshaling->aabbs));
+ (void)rootType;
+ marshal_VkGeometryTrianglesNV(vkStream, rootType, (VkGeometryTrianglesNV*)(&forMarshaling->triangles));
+ marshal_VkGeometryAABBNV(vkStream, rootType, (VkGeometryAABBNV*)(&forMarshaling->aabbs));
}
void unmarshal_VkGeometryDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeometryDataNV* forUnmarshaling)
{
- unmarshal_VkGeometryTrianglesNV(vkStream, (VkGeometryTrianglesNV*)(&forUnmarshaling->triangles));
- unmarshal_VkGeometryAABBNV(vkStream, (VkGeometryAABBNV*)(&forUnmarshaling->aabbs));
+ (void)rootType;
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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_VkGeometryDataNV(vkStream, (VkGeometryDataNV*)(&forMarshaling->geometry));
+ marshal_VkGeometryDataNV(vkStream, rootType, (VkGeometryDataNV*)(&forMarshaling->geometry));
vkStream->write((VkGeometryFlagsKHR*)&forMarshaling->flags, sizeof(VkGeometryFlagsKHR));
}
void unmarshal_VkGeometryNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeometryNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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_VkGeometryDataNV(vkStream, (VkGeometryDataNV*)(&forUnmarshaling->geometry));
+ unmarshal_VkGeometryDataNV(vkStream, rootType, (VkGeometryDataNV*)(&forUnmarshaling->geometry));
vkStream->read((VkGeometryFlagsKHR*)&forUnmarshaling->flags, sizeof(VkGeometryFlagsKHR));
}
void marshal_VkAccelerationStructureInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
@@ -13022,17 +17430,23 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i)
{
- marshal_VkGeometryNV(vkStream, (const VkGeometryNV*)(forMarshaling->pGeometries + i));
+ marshal_VkGeometryNV(vkStream, rootType, (const VkGeometryNV*)(forMarshaling->pGeometries + i));
}
}
}
void unmarshal_VkAccelerationStructureInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
@@ -13041,37 +17455,55 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->geometryCount; ++i)
{
- unmarshal_VkGeometryNV(vkStream, (VkGeometryNV*)(forUnmarshaling->pGeometries + i));
+ unmarshal_VkGeometryNV(vkStream, rootType, (VkGeometryNV*)(forUnmarshaling->pGeometries + i));
}
}
}
void marshal_VkAccelerationStructureCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkAccelerationStructureInfoNV*)(&forMarshaling->info));
+ marshal_VkAccelerationStructureInfoNV(vkStream, rootType, (VkAccelerationStructureInfoNV*)(&forMarshaling->info));
}
void unmarshal_VkAccelerationStructureCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkAccelerationStructureInfoNV*)(&forUnmarshaling->info));
+ unmarshal_VkAccelerationStructureInfoNV(vkStream, rootType, (VkAccelerationStructureInfoNV*)(&forUnmarshaling->info));
}
void marshal_VkBindAccelerationStructureMemoryInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindAccelerationStructureMemoryInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -13085,10 +17517,16 @@
void unmarshal_VkBindAccelerationStructureMemoryInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindAccelerationStructureMemoryInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -13102,10 +17540,16 @@
void marshal_VkWriteDescriptorSetAccelerationStructureNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->accelerationStructureCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAccelerationStructures;
@@ -13124,10 +17568,16 @@
void unmarshal_VkWriteDescriptorSetAccelerationStructureNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWriteDescriptorSetAccelerationStructureNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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;
@@ -13150,10 +17600,16 @@
void marshal_VkAccelerationStructureMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkAccelerationStructureMemoryRequirementsTypeNV*)&forMarshaling->type, sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(&forMarshaling->accelerationStructure, &cgen_var_0, 1);
@@ -13162,10 +17618,16 @@
void unmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureMemoryRequirementsInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
@@ -13174,10 +17636,16 @@
void marshal_VkPhysicalDeviceRayTracingPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleSize, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxRecursionDepth, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxShaderGroupStride, sizeof(uint32_t));
@@ -13190,10 +17658,16 @@
void unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRayTracingPropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleSize, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxRecursionDepth, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxShaderGroupStride, sizeof(uint32_t));
@@ -13206,22 +17680,28 @@
void marshal_VkTransformMatrixKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTransformMatrixKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((float*)forMarshaling->matrix, ((3)*(4)) * sizeof(float));
}
void unmarshal_VkTransformMatrixKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkTransformMatrixKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((float*)forUnmarshaling->matrix, ((3)*(4)) * sizeof(float));
}
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));
vkStream->write((float*)&forMarshaling->minZ, sizeof(float));
@@ -13232,8 +17712,10 @@
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));
vkStream->read((float*)&forUnmarshaling->minZ, sizeof(float));
@@ -13244,8 +17726,10 @@
void marshal_VkAccelerationStructureInstanceKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureInstanceKHR* forMarshaling)
{
+ (void)rootType;
typedef struct VkAccelerationStructureInstanceKHRWithoutBitFields {
VkTransformMatrixKHR transform;
@@ -13254,7 +17738,7 @@
} VkAccelerationStructureInstanceKHRWithoutBitFields;
const VkAccelerationStructureInstanceKHRWithoutBitFields* forMarshaling_new = (const VkAccelerationStructureInstanceKHRWithoutBitFields*)(forMarshaling);
- marshal_VkTransformMatrixKHR(vkStream, (VkTransformMatrixKHR*)(&forMarshaling_new->transform));
+ 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));
}
@@ -13264,8 +17748,10 @@
void unmarshal_VkAccelerationStructureInstanceKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureInstanceKHR* forUnmarshaling)
{
+ (void)rootType;
typedef struct VkAccelerationStructureInstanceKHRWithoutBitFields {
VkTransformMatrixKHR transform;
@@ -13274,7 +17760,7 @@
} VkAccelerationStructureInstanceKHRWithoutBitFields;
VkAccelerationStructureInstanceKHRWithoutBitFields* forUnmarshaling_new = (VkAccelerationStructureInstanceKHRWithoutBitFields*)(forUnmarshaling);
- unmarshal_VkTransformMatrixKHR(vkStream, (VkTransformMatrixKHR*)(&forUnmarshaling_new->transform));
+ 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));
}
@@ -13286,37 +17772,61 @@
#ifdef VK_NV_representative_fragment_test
void marshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->representativeFragmentTest, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->representativeFragmentTest, sizeof(VkBool32));
}
void marshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->representativeFragmentTestEnable, sizeof(VkBool32));
}
void unmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->representativeFragmentTestEnable, sizeof(VkBool32));
}
@@ -13324,38 +17834,62 @@
#ifdef VK_EXT_filter_cubic
void marshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageViewType*)&forMarshaling->imageViewType, sizeof(VkImageViewType));
}
void unmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImageViewImageFormatInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkImageViewType*)&forUnmarshaling->imageViewType, sizeof(VkImageViewType));
}
void marshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->filterCubic, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->filterCubicMinmax, sizeof(VkBool32));
}
void unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFilterCubicImageViewImageFormatPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->filterCubic, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->filterCubicMinmax, sizeof(VkBool32));
}
@@ -13366,19 +17900,31 @@
#ifdef VK_EXT_global_priority
void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
}
void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -13386,10 +17932,16 @@
#ifdef VK_EXT_external_memory_host
void marshal_VkImportMemoryHostPointerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryHostPointerInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
@@ -13402,10 +17954,16 @@
void unmarshal_VkImportMemoryHostPointerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportMemoryHostPointerInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
void* check_pHostPointer;
@@ -13422,37 +17980,61 @@
void marshal_VkMemoryHostPointerPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryHostPointerPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
}
void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -13462,19 +18044,31 @@
#ifdef VK_AMD_pipeline_compiler_control
void marshal_VkPipelineCompilerControlCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineCompilerControlFlagsAMD*)&forMarshaling->compilerControlFlags, sizeof(VkPipelineCompilerControlFlagsAMD));
}
void unmarshal_VkPipelineCompilerControlCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCompilerControlCreateInfoAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -13482,19 +18076,31 @@
#ifdef VK_EXT_calibrated_timestamps
void marshal_VkCalibratedTimestampInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCalibratedTimestampInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkTimeDomainEXT*)&forUnmarshaling->timeDomain, sizeof(VkTimeDomainEXT));
}
@@ -13502,10 +18108,16 @@
#ifdef VK_AMD_shader_core_properties
void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->shaderEngineCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->shaderArraysPerEngineCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->computeUnitsPerShaderArray, sizeof(uint32_t));
@@ -13524,10 +18136,16 @@
void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->shaderEngineCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->shaderArraysPerEngineCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->computeUnitsPerShaderArray, sizeof(uint32_t));
@@ -13548,19 +18166,31 @@
#ifdef VK_AMD_memory_overallocation_behavior
void marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkMemoryOverallocationBehaviorAMD*)&forMarshaling->overallocationBehavior, sizeof(VkMemoryOverallocationBehaviorAMD));
}
void unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceMemoryOverallocationCreateInfoAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -13568,86 +18198,126 @@
#ifdef VK_EXT_vertex_attribute_divisor
void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
}
void marshal_VkVertexInputBindingDivisorDescriptionEXT(
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)
{
+ (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)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling->pVertexBindingDivisors + i));
+ marshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, rootType, (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling->pVertexBindingDivisors + i));
}
}
}
void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkVertexInputBindingDivisorDescriptionEXT*)(forUnmarshaling->pVertexBindingDivisors + i));
+ unmarshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, rootType, (VkVertexInputBindingDivisorDescriptionEXT*)(forUnmarshaling->pVertexBindingDivisors + i));
}
}
}
void marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -13656,19 +18326,31 @@
#ifdef VK_GGP_frame_token
void marshal_VkPresentFrameTokenGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentFrameTokenGGP* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((GgpFrameToken*)&forUnmarshaling->frameToken, sizeof(GgpFrameToken));
}
@@ -13676,50 +18358,66 @@
#ifdef VK_EXT_pipeline_creation_feedback
void marshal_VkPipelineCreationFeedbackEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackEXT* forMarshaling)
{
+ (void)rootType;
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)rootType;
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)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkPipelineCreationFeedbackEXT(vkStream, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineCreationFeedback));
+ 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, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks + i));
+ marshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks + i));
}
}
}
void unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkPipelineCreationFeedbackEXT(vkStream, (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineCreationFeedback));
+ 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, (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineStageCreationFeedbacks + i));
+ unmarshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineStageCreationFeedbacks + i));
}
}
}
@@ -13730,20 +18428,32 @@
#ifdef VK_NV_compute_shader_derivatives
void marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->computeDerivativeGroupQuads, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->computeDerivativeGroupLinear, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->computeDerivativeGroupQuads, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->computeDerivativeGroupLinear, sizeof(VkBool32));
}
@@ -13752,30 +18462,48 @@
#ifdef VK_NV_mesh_shader
void marshal_VkPhysicalDeviceMeshShaderFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->taskShader, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->meshShader, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMeshShaderFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->taskShader, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->meshShader, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceMeshShaderPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxDrawMeshTasksCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
vkStream->write((uint32_t*)forMarshaling->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
@@ -13793,10 +18521,16 @@
void unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMeshShaderPropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxDrawMeshTasksCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
vkStream->read((uint32_t*)forUnmarshaling->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
@@ -13814,16 +18548,20 @@
void marshal_VkDrawMeshTasksIndirectCommandNV(
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)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->taskCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->firstTask, sizeof(uint32_t));
}
@@ -13832,19 +18570,31 @@
#ifdef VK_NV_fragment_shader_barycentric
void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
}
@@ -13852,19 +18602,31 @@
#ifdef VK_NV_shader_image_footprint
void marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->imageFootprint, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderImageFootprintFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->imageFootprint, sizeof(VkBool32));
}
@@ -13872,10 +18634,16 @@
#ifdef VK_NV_scissor_exclusive
void marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->exclusiveScissorCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pExclusiveScissors;
@@ -13886,7 +18654,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->exclusiveScissorCount; ++i)
{
- marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pExclusiveScissors + i));
+ marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pExclusiveScissors + i));
}
}
}
@@ -13894,10 +18662,16 @@
void unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportExclusiveScissorStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->exclusiveScissorCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkRect2D* check_pExclusiveScissors;
@@ -13912,7 +18686,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->exclusiveScissorCount; ++i)
{
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pExclusiveScissors + i));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pExclusiveScissors + i));
}
}
}
@@ -13920,19 +18694,31 @@
void marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->exclusiveScissor, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExclusiveScissorFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->exclusiveScissor, sizeof(VkBool32));
}
@@ -13940,28 +18726,46 @@
#ifdef VK_NV_device_diagnostic_checkpoints
void marshal_VkQueueFamilyCheckpointPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueueFamilyCheckpointPropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
}
void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkCheckpointDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCheckpointDataNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
@@ -13974,10 +18778,16 @@
void unmarshal_VkCheckpointDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCheckpointDataNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
void* check_pCheckpointMarker;
@@ -13996,19 +18806,31 @@
#ifdef VK_INTEL_shader_integer_functions2
void marshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderIntegerFunctions2, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderIntegerFunctions2, sizeof(VkBool32));
}
@@ -14016,40 +18838,54 @@
#ifdef VK_INTEL_performance_query
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)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->value32, sizeof(uint32_t));
}
void marshal_VkPerformanceValueINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceValueINTEL* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkPerformanceValueTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceValueTypeINTEL));
- marshal_VkPerformanceValueDataINTEL(vkStream, (VkPerformanceValueDataINTEL*)(&forMarshaling->data));
+ marshal_VkPerformanceValueDataINTEL(vkStream, rootType, (VkPerformanceValueDataINTEL*)(&forMarshaling->data));
}
void unmarshal_VkPerformanceValueINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceValueINTEL* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkPerformanceValueTypeINTEL*)&forUnmarshaling->type, sizeof(VkPerformanceValueTypeINTEL));
- unmarshal_VkPerformanceValueDataINTEL(vkStream, (VkPerformanceValueDataINTEL*)(&forUnmarshaling->data));
+ unmarshal_VkPerformanceValueDataINTEL(vkStream, rootType, (VkPerformanceValueDataINTEL*)(&forUnmarshaling->data));
}
void marshal_VkInitializePerformanceApiInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkInitializePerformanceApiInfoINTEL* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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);
@@ -14061,10 +18897,16 @@
void unmarshal_VkInitializePerformanceApiInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkInitializePerformanceApiInfoINTEL* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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();
@@ -14080,64 +18922,106 @@
void marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkQueryPoolSamplingModeINTEL*)&forMarshaling->performanceCountersSampling, sizeof(VkQueryPoolSamplingModeINTEL));
}
void unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueryPoolPerformanceQueryCreateInfoINTEL* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPerformanceMarkerInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceMarkerInfoINTEL* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint64_t*)&forUnmarshaling->marker, sizeof(uint64_t));
}
void marshal_VkPerformanceStreamMarkerInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceStreamMarkerInfoINTEL* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->marker, sizeof(uint32_t));
}
void unmarshal_VkPerformanceStreamMarkerInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceStreamMarkerInfoINTEL* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->enable, sizeof(VkBool32));
vkStream->write((uint64_t*)&forMarshaling->parameter, sizeof(uint64_t));
@@ -14145,10 +19029,16 @@
void unmarshal_VkPerformanceOverrideInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceOverrideInfoINTEL* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->enable, sizeof(VkBool32));
vkStream->read((uint64_t*)&forUnmarshaling->parameter, sizeof(uint64_t));
@@ -14156,19 +19046,31 @@
void marshal_VkPerformanceConfigurationAcquireInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPerformanceConfigurationTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceConfigurationTypeINTEL));
}
void unmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceConfigurationAcquireInfoINTEL* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -14176,10 +19078,16 @@
#ifdef VK_EXT_pci_bus_info
void marshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->pciDomain, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->pciBus, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->pciDevice, sizeof(uint32_t));
@@ -14188,10 +19096,16 @@
void unmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePCIBusInfoPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->pciDomain, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->pciBus, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->pciDevice, sizeof(uint32_t));
@@ -14202,37 +19116,61 @@
#ifdef VK_AMD_display_native_hdr
void marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->localDimmingSupport, sizeof(VkBool32));
}
void unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayNativeHdrSurfaceCapabilitiesAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->localDimmingSupport, sizeof(VkBool32));
}
void marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->localDimmingEnable, sizeof(VkBool32));
}
void unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSwapchainDisplayNativeHdrCreateInfoAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->localDimmingEnable, sizeof(VkBool32));
}
@@ -14240,20 +19178,32 @@
#ifdef VK_FUCHSIA_imagepipe_surface
void marshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((zx_handle_t*)&forMarshaling->imagePipeHandle, sizeof(zx_handle_t));
}
void unmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImagePipeSurfaceCreateInfoFUCHSIA* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((zx_handle_t*)&forUnmarshaling->imagePipeHandle, sizeof(zx_handle_t));
}
@@ -14262,10 +19212,16 @@
#ifdef VK_EXT_metal_surface
void marshal_VkMetalSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMetalSurfaceCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkMetalSurfaceCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkMetalSurfaceCreateFlagsEXT));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pLayer;
@@ -14278,10 +19234,16 @@
void unmarshal_VkMetalSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMetalSurfaceCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkMetalSurfaceCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkMetalSurfaceCreateFlagsEXT));
// WARNING PTR CHECK
const CAMetalLayer* check_pLayer;
@@ -14297,67 +19259,106 @@
}
#endif
-#ifdef VK_GOOGLE_color_buffer
-void marshal_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
VulkanStreamGuest* vkStream,
- const VkImportColorBufferGOOGLE* forMarshaling)
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->colorBuffer, sizeof(uint32_t));
+ 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));
}
-void unmarshal_VkImportColorBufferGOOGLE(
+void unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
VulkanStreamGuest* vkStream,
- VkImportColorBufferGOOGLE* forUnmarshaling)
+ VkStructureType rootType,
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->colorBuffer, sizeof(uint32_t));
+ forUnmarshaling->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
+ 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));
}
-void marshal_VkImportBufferGOOGLE(
+void marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
VulkanStreamGuest* vkStream,
- const VkImportBufferGOOGLE* forMarshaling)
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->buffer, sizeof(uint32_t));
+ 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));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentDensityInvocations, sizeof(VkBool32));
}
-void unmarshal_VkImportBufferGOOGLE(
+void unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
VulkanStreamGuest* vkStream,
- VkImportBufferGOOGLE* forUnmarshaling)
+ VkStructureType rootType,
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->buffer, sizeof(uint32_t));
+ forUnmarshaling->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
+ 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));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityInvocations, sizeof(VkBool32));
}
-void marshal_VkImportPhysicalAddressGOOGLE(
+void marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
VulkanStreamGuest* vkStream,
- const VkImportPhysicalAddressGOOGLE* forMarshaling)
+ VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- vkStream->write((uint64_t*)&forMarshaling->physicalAddress, sizeof(uint64_t));
- vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
- vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
- vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
- vkStream->write((uint32_t*)&forMarshaling->tilingParameter, sizeof(uint32_t));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(&forMarshaling->fragmentDensityMapAttachment));
}
-void unmarshal_VkImportPhysicalAddressGOOGLE(
+void unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
VulkanStreamGuest* vkStream,
- VkImportPhysicalAddressGOOGLE* forUnmarshaling)
+ VkStructureType rootType,
+ VkRenderPassFragmentDensityMapCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint64_t*)&forUnmarshaling->physicalAddress, sizeof(uint64_t));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
- vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
- vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
- vkStream->read((uint32_t*)&forUnmarshaling->tilingParameter, sizeof(uint32_t));
+ forUnmarshaling->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
+ 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));
}
#endif
@@ -14370,30 +19371,48 @@
#ifdef VK_EXT_subgroup_size_control
void marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->subgroupSizeControl, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->computeFullSubgroups, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->subgroupSizeControl, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->computeFullSubgroups, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -14402,10 +19421,16 @@
void unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -14414,19 +19439,31 @@
void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->requiredSubgroupSize, sizeof(uint32_t));
}
void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->requiredSubgroupSize, sizeof(uint32_t));
}
@@ -14434,20 +19471,32 @@
#ifdef VK_AMD_shader_core_properties2
void marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->activeComputeUnitCount, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderCoreProperties2AMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->activeComputeUnitCount, sizeof(uint32_t));
}
@@ -14456,19 +19505,31 @@
#ifdef VK_AMD_device_coherent_memory
void marshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->deviceCoherentMemory, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCoherentMemoryFeaturesAMD* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->deviceCoherentMemory, sizeof(VkBool32));
}
@@ -14476,20 +19537,32 @@
#ifdef VK_EXT_shader_image_atomic_int64
void marshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderImageInt64Atomics, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->sparseImageInt64Atomics, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderImageInt64Atomics, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->sparseImageInt64Atomics, sizeof(VkBool32));
}
@@ -14498,20 +19571,32 @@
#ifdef VK_EXT_memory_budget
void marshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMemoryBudgetPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -14520,37 +19605,61 @@
#ifdef VK_EXT_memory_priority
void marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->memoryPriority, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMemoryPriorityFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((float*)&forUnmarshaling->priority, sizeof(float));
}
@@ -14558,19 +19667,31 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
void marshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocationImageAliasing, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocationImageAliasing, sizeof(VkBool32));
}
@@ -14578,10 +19699,16 @@
#ifdef VK_EXT_buffer_device_address
void marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddress, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
@@ -14589,10 +19716,16 @@
void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddress, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
@@ -14600,19 +19733,31 @@
void marshal_VkBufferDeviceAddressCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferDeviceAddressCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
void unmarshal_VkBufferDeviceAddressCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferDeviceAddressCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
@@ -14620,10 +19765,16 @@
#ifdef VK_EXT_tooling_info
void marshal_VkPhysicalDeviceToolPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceToolPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -14633,10 +19784,16 @@
void unmarshal_VkPhysicalDeviceToolPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -14650,10 +19807,16 @@
#ifdef VK_EXT_validation_features
void marshal_VkValidationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->disabledValidationFeatureCount, sizeof(uint32_t));
@@ -14662,10 +19825,16 @@
void unmarshal_VkValidationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkValidationFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->disabledValidationFeatureCount, sizeof(uint32_t));
@@ -14676,10 +19845,16 @@
#ifdef VK_NV_cooperative_matrix
void marshal_VkCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCooperativeMatrixPropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->MSize, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->NSize, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->KSize, sizeof(uint32_t));
@@ -14692,10 +19867,16 @@
void unmarshal_VkCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCooperativeMatrixPropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->MSize, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->NSize, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->KSize, sizeof(uint32_t));
@@ -14708,39 +19889,63 @@
void marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCooperativeMatrixFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkShaderStageFlags*)&forMarshaling->cooperativeMatrixSupportedStages, sizeof(VkShaderStageFlags));
}
void unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCooperativeMatrixPropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -14748,48 +19953,78 @@
#ifdef VK_NV_coverage_reduction_mode
void marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->coverageReductionMode, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCoverageReductionModeFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->coverageReductionMode, sizeof(VkBool32));
}
void marshal_VkPipelineCoverageReductionStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCoverageReductionStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkFramebufferMixedSamplesCombinationNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -14798,10 +20033,16 @@
void unmarshal_VkFramebufferMixedSamplesCombinationNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFramebufferMixedSamplesCombinationNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -14812,10 +20053,16 @@
#ifdef VK_EXT_fragment_shader_interlock
void marshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -14823,10 +20070,16 @@
void unmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -14836,19 +20089,31 @@
#ifdef VK_EXT_ycbcr_image_arrays
void marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->ycbcrImageArrays, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->ycbcrImageArrays, sizeof(VkBool32));
}
@@ -14856,55 +20121,91 @@
#ifdef VK_EXT_full_screen_exclusive
void marshal_VkSurfaceFullScreenExclusiveInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFullScreenExclusiveEXT*)&forMarshaling->fullScreenExclusive, sizeof(VkFullScreenExclusiveEXT));
}
void unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceFullScreenExclusiveInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->fullScreenExclusiveSupported, sizeof(VkBool32));
}
void unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceCapabilitiesFullScreenExclusiveEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->fullScreenExclusiveSupported, sizeof(VkBool32));
}
void marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((HMONITOR*)&forMarshaling->hmonitor, sizeof(HMONITOR));
}
void unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceFullScreenExclusiveWin32InfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((HMONITOR*)&forUnmarshaling->hmonitor, sizeof(HMONITOR));
}
@@ -14912,19 +20213,31 @@
#ifdef VK_EXT_headless_surface
void marshal_VkHeadlessSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkHeadlessSurfaceCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkHeadlessSurfaceCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkHeadlessSurfaceCreateFlagsEXT));
}
void unmarshal_VkHeadlessSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkHeadlessSurfaceCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -14932,10 +20245,16 @@
#ifdef VK_EXT_line_rasterization
void marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->smoothLines, sizeof(VkBool32));
@@ -14946,10 +20265,16 @@
void unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceLineRasterizationFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->rectangularLines, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->bresenhamLines, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->smoothLines, sizeof(VkBool32));
@@ -14960,28 +20285,46 @@
void marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceLineRasterizationPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
}
void marshal_VkPipelineRasterizationLineStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->lineStippleFactor, sizeof(uint32_t));
@@ -14990,10 +20333,16 @@
void unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationLineStateCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((VkBool32*)&forUnmarshaling->stippledLineEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->lineStippleFactor, sizeof(uint32_t));
@@ -15004,10 +20353,16 @@
#ifdef VK_EXT_shader_atomic_float
void marshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat32Atomics, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat32AtomicAdd, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderBufferFloat64Atomics, sizeof(VkBool32));
@@ -15024,10 +20379,16 @@
void unmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat32Atomics, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat32AtomicAdd, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferFloat64Atomics, sizeof(VkBool32));
@@ -15048,19 +20409,31 @@
#ifdef VK_EXT_index_type_uint8
void marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->indexTypeUint8, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->indexTypeUint8, sizeof(VkBool32));
}
@@ -15068,19 +20441,31 @@
#ifdef VK_EXT_extended_dynamic_state
void marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState, sizeof(VkBool32));
}
@@ -15088,19 +20473,31 @@
#ifdef VK_EXT_shader_demote_to_helper_invocation
void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
}
@@ -15108,10 +20505,16 @@
#ifdef VK_NV_device_generated_commands
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxGraphicsShaderGroupCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxIndirectSequenceCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsTokenCount, sizeof(uint32_t));
@@ -15125,10 +20528,16 @@
void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxGraphicsShaderGroupCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectSequenceCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsTokenCount, sizeof(uint32_t));
@@ -15142,34 +20551,52 @@
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->deviceGeneratedCommands, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->deviceGeneratedCommands, sizeof(VkBool32));
}
void marshal_VkGraphicsShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsShaderGroupCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
}
// WARNING PTR CHECK
@@ -15177,29 +20604,35 @@
vkStream->putBe64(cgen_var_0);
if (forMarshaling->pVertexInputState)
{
- marshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(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, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+ marshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
}
}
void unmarshal_VkGraphicsShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGraphicsShaderGroupCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
}
// WARNING PTR CHECK
@@ -15211,7 +20644,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pVertexInputState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
+ unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
}
// WARNING PTR CHECK
const VkPipelineTessellationStateCreateInfo* check_pTessellationState;
@@ -15222,22 +20655,28 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pTessellationState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+ unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
}
}
void marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
+ marshal_VkGraphicsShaderGroupCreateInfoNV(vkStream, rootType, (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->pipelineCount, sizeof(uint32_t));
@@ -15252,16 +20691,22 @@
void unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGraphicsPipelineShaderGroupsCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkGraphicsShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
+ unmarshal_VkGraphicsShaderGroupCreateInfoNV(vkStream, rootType, (VkGraphicsShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->pipelineCount, sizeof(uint32_t));
@@ -15276,22 +20721,28 @@
void marshal_VkBindShaderGroupIndirectCommandNV(
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)
{
+ (void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->groupIndex, sizeof(uint32_t));
}
void marshal_VkBindIndexBufferIndirectCommandNV(
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));
vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
@@ -15299,8 +20750,10 @@
void unmarshal_VkBindIndexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindIndexBufferIndirectCommandNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->bufferAddress, sizeof(VkDeviceAddress));
vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
@@ -15308,8 +20761,10 @@
void marshal_VkBindVertexBufferIndirectCommandNV(
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));
vkStream->write((uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
@@ -15317,8 +20772,10 @@
void unmarshal_VkBindVertexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindVertexBufferIndirectCommandNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->bufferAddress, sizeof(VkDeviceAddress));
vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->stride, sizeof(uint32_t));
@@ -15326,22 +20783,28 @@
void marshal_VkSetStateFlagsIndirectCommandNV(
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)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->data, sizeof(uint32_t));
}
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);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -15350,8 +20813,10 @@
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);
@@ -15360,10 +20825,16 @@
void marshal_VkIndirectCommandsLayoutTokenNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutTokenNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->stream, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
@@ -15383,10 +20854,16 @@
void unmarshal_VkIndirectCommandsLayoutTokenNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkIndirectCommandsLayoutTokenNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->stream, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
@@ -15406,10 +20883,16 @@
void marshal_VkIndirectCommandsLayoutCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->tokenCount, sizeof(uint32_t));
@@ -15417,7 +20900,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i)
{
- marshal_VkIndirectCommandsLayoutTokenNV(vkStream, (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i));
+ marshal_VkIndirectCommandsLayoutTokenNV(vkStream, rootType, (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->streamCount, sizeof(uint32_t));
@@ -15426,10 +20909,16 @@
void unmarshal_VkIndirectCommandsLayoutCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkIndirectCommandsLayoutCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->tokenCount, sizeof(uint32_t));
@@ -15437,7 +20926,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->tokenCount; ++i)
{
- unmarshal_VkIndirectCommandsLayoutTokenNV(vkStream, (VkIndirectCommandsLayoutTokenNV*)(forUnmarshaling->pTokens + i));
+ unmarshal_VkIndirectCommandsLayoutTokenNV(vkStream, rootType, (VkIndirectCommandsLayoutTokenNV*)(forUnmarshaling->pTokens + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->streamCount, sizeof(uint32_t));
@@ -15446,10 +20935,16 @@
void marshal_VkGeneratedCommandsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeneratedCommandsInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
@@ -15462,7 +20957,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->streamCount; ++i)
{
- marshal_VkIndirectCommandsStreamNV(vkStream, (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i));
+ marshal_VkIndirectCommandsStreamNV(vkStream, rootType, (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->sequencesCount, sizeof(uint32_t));
@@ -15483,10 +20978,16 @@
void unmarshal_VkGeneratedCommandsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeneratedCommandsInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
@@ -15499,7 +21000,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->streamCount; ++i)
{
- unmarshal_VkIndirectCommandsStreamNV(vkStream, (VkIndirectCommandsStreamNV*)(forUnmarshaling->pStreams + i));
+ unmarshal_VkIndirectCommandsStreamNV(vkStream, rootType, (VkIndirectCommandsStreamNV*)(forUnmarshaling->pStreams + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->sequencesCount, sizeof(uint32_t));
@@ -15520,10 +21021,16 @@
void marshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
@@ -15536,10 +21043,16 @@
void unmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeneratedCommandsMemoryRequirementsInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
@@ -15554,28 +21067,46 @@
#ifdef VK_EXT_texel_buffer_alignment
void marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->texelBufferAlignment, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->texelBufferAlignment, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -15584,10 +21115,16 @@
void unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -15598,68 +21135,110 @@
#ifdef VK_QCOM_render_pass_transform
void marshal_VkRenderPassTransformBeginInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassTransformBeginInfoQCOM* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
}
void unmarshal_VkRenderPassTransformBeginInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassTransformBeginInfoQCOM* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
- marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea));
+ marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea));
}
void unmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
- unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->renderArea));
+ unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
}
#endif
#ifdef VK_EXT_device_memory_report
void marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->deviceMemoryReport, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->deviceMemoryReport, sizeof(VkBool32));
}
void marshal_VkDeviceMemoryReportCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryReportCallbackDataEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint64_t*)&forMarshaling->memoryObjectId, sizeof(uint64_t));
@@ -15671,10 +21250,16 @@
void unmarshal_VkDeviceMemoryReportCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceMemoryReportCallbackDataEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint64_t*)&forUnmarshaling->memoryObjectId, sizeof(uint64_t));
@@ -15686,10 +21271,16 @@
void marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDeviceMemoryReportFlagsEXT));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
vkStream->putBe64(cgen_var_0);
@@ -15698,10 +21289,16 @@
void unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceDeviceMemoryReportCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
forUnmarshaling->pfnUserCallback = (PFN_vkDeviceMemoryReportCallbackEXT)vkStream->getBe64();
vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
@@ -15711,10 +21308,16 @@
#ifdef VK_EXT_robustness2
void marshal_VkPhysicalDeviceRobustness2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->robustBufferAccess2, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->robustImageAccess2, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->nullDescriptor, sizeof(VkBool32));
@@ -15722,10 +21325,16 @@
void unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRobustness2FeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccess2, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->robustImageAccess2, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->nullDescriptor, sizeof(VkBool32));
@@ -15733,20 +21342,32 @@
void marshal_VkPhysicalDeviceRobustness2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRobustness2PropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -15755,58 +21376,94 @@
#ifdef VK_EXT_custom_border_color
void marshal_VkSamplerCustomBorderColorCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forMarshaling->customBorderColor));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forMarshaling->customBorderColor));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
}
void unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerCustomBorderColorCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forUnmarshaling->customBorderColor));
+ 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));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
}
void marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxCustomBorderColorSamplers, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCustomBorderColorPropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxCustomBorderColorSamplers, sizeof(uint32_t));
}
void marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->customBorderColors, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->customBorderColorWithoutFormat, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCustomBorderColorFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->customBorderColors, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->customBorderColorWithoutFormat, sizeof(VkBool32));
}
@@ -15817,55 +21474,91 @@
#ifdef VK_EXT_private_data
void marshal_VkPhysicalDevicePrivateDataFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->privateData, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->privateData, sizeof(VkBool32));
}
void marshal_VkDevicePrivateDataCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDevicePrivateDataCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPrivateDataSlotCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPrivateDataSlotCreateFlagsEXT));
}
void unmarshal_VkPrivateDataSlotCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPrivateDataSlotCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -15873,19 +21566,31 @@
#ifdef VK_EXT_pipeline_creation_cache_control
void marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
}
@@ -15893,37 +21598,61 @@
#ifdef VK_NV_device_diagnostics_config
void marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->diagnosticsConfig, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->diagnosticsConfig, sizeof(VkBool32));
}
void marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceDiagnosticsConfigFlagsNV*)&forMarshaling->flags, sizeof(VkDeviceDiagnosticsConfigFlagsNV));
}
void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -15933,10 +21662,16 @@
#ifdef VK_NV_fragment_shading_rate_enums
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateEnums, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->supersampleFragmentShadingRates, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->noInvocationFragmentShadingRates, sizeof(VkBool32));
@@ -15944,10 +21679,16 @@
void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateEnums, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->supersampleFragmentShadingRates, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->noInvocationFragmentShadingRates, sizeof(VkBool32));
@@ -15955,28 +21696,46 @@
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateInvocationCount, sizeof(VkSampleCountFlagBits));
}
void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -15984,10 +21743,16 @@
void unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -15997,28 +21762,46 @@
#ifdef VK_EXT_fragment_density_map2
void marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapDeferred, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapDeferred, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->maxSubsampledArrayLayers, sizeof(uint32_t));
@@ -16027,10 +21810,16 @@
void unmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->maxSubsampledArrayLayers, sizeof(uint32_t));
@@ -16041,19 +21830,31 @@
#ifdef VK_QCOM_rotated_copy_commands
void marshal_VkCopyCommandTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyCommandTransformInfoQCOM* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
}
void unmarshal_VkCopyCommandTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyCommandTransformInfoQCOM* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
@@ -16061,19 +21862,31 @@
#ifdef VK_EXT_image_robustness
void marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->robustImageAccess, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->robustImageAccess, sizeof(VkBool32));
}
@@ -16081,20 +21894,32 @@
#ifdef VK_EXT_4444_formats
void marshal_VkPhysicalDevice4444FormatsFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->formatA4R4G4B4, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->formatA4B4G4R4, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevice4444FormatsFeaturesEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->formatA4R4G4B4, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->formatA4B4G4R4, sizeof(VkBool32));
}
@@ -16103,10 +21928,16 @@
#ifdef VK_EXT_directfb_surface
void marshal_VkDirectFBSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDirectFBSurfaceCreateInfoEXT* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDirectFBSurfaceCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDirectFBSurfaceCreateFlagsEXT));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dfb;
@@ -16126,10 +21957,16 @@
void unmarshal_VkDirectFBSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDirectFBSurfaceCreateInfoEXT* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
// WARNING PTR CHECK
IDirectFB* check_dfb;
@@ -16157,40 +21994,151 @@
#endif
#ifdef VK_GOOGLE_gfxstream
+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)
+ {
+ 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)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ forUnmarshaling->sType = VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE;
+ 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)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ 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)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ forUnmarshaling->sType = VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE;
+ 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)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint64_t*)&forMarshaling->physicalAddress, sizeof(uint64_t));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+ vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
+ vkStream->write((uint32_t*)&forMarshaling->tilingParameter, sizeof(uint32_t));
+}
+
+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)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((uint64_t*)&forUnmarshaling->physicalAddress, sizeof(uint64_t));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+ vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+ vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
+ vkStream->read((uint32_t*)&forUnmarshaling->tilingParameter, sizeof(uint32_t));
+}
+
#endif
#ifdef VK_KHR_acceleration_structure
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)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
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)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
void marshal_VkAccelerationStructureBuildRangeInfoKHR(
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));
vkStream->write((uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
@@ -16199,8 +22147,10 @@
void unmarshal_VkAccelerationStructureBuildRangeInfoKHR(
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));
vkStream->read((uint32_t*)&forUnmarshaling->firstVertex, sizeof(uint32_t));
@@ -16209,116 +22159,174 @@
void marshal_VkAccelerationStructureGeometryTrianglesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (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, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexData));
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, (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)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (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, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexData));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, (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)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
vkStream->write((VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
}
void unmarshal_VkAccelerationStructureGeometryAabbsDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureGeometryAabbsDataKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
+ 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));
vkStream->read((VkDeviceSize*)&forUnmarshaling->stride, sizeof(VkDeviceSize));
}
void marshal_VkAccelerationStructureGeometryInstancesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
+ marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
}
void unmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureGeometryInstancesDataKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
+ unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
}
void marshal_VkAccelerationStructureGeometryDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryDataKHR* forMarshaling)
{
- marshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles));
+ (void)rootType;
+ marshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles));
}
void unmarshal_VkAccelerationStructureGeometryDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureGeometryDataKHR* forUnmarshaling)
{
- unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forUnmarshaling->triangles));
+ (void)rootType;
+ unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forUnmarshaling->triangles));
}
void marshal_VkAccelerationStructureGeometryKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (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)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (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)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -16338,19 +22346,25 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i)
{
- marshal_VkAccelerationStructureGeometryKHR(vkStream, (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i));
+ marshal_VkAccelerationStructureGeometryKHR(vkStream, rootType, (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i));
}
}
}
- marshal_VkDeviceOrHostAddressKHR(vkStream, (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData));
+ marshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData));
}
void unmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureBuildGeometryInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -16374,19 +22388,25 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->geometryCount; ++i)
{
- unmarshal_VkAccelerationStructureGeometryKHR(vkStream, (VkAccelerationStructureGeometryKHR*)(forUnmarshaling->pGeometries + i));
+ unmarshal_VkAccelerationStructureGeometryKHR(vkStream, rootType, (VkAccelerationStructureGeometryKHR*)(forUnmarshaling->pGeometries + i));
}
}
}
- unmarshal_VkDeviceOrHostAddressKHR(vkStream, (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->scratchData));
+ unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->scratchData));
}
void marshal_VkAccelerationStructureCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkAccelerationStructureCreateFlagsKHR*)&forMarshaling->createFlags, sizeof(VkAccelerationStructureCreateFlagsKHR));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
@@ -16399,10 +22419,16 @@
void unmarshal_VkAccelerationStructureCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
@@ -16415,10 +22441,16 @@
void marshal_VkWriteDescriptorSetAccelerationStructureKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->accelerationStructureCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAccelerationStructures;
@@ -16437,10 +22469,16 @@
void unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWriteDescriptorSetAccelerationStructureKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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;
@@ -16463,10 +22501,16 @@
void marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -16476,10 +22520,16 @@
void unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceAccelerationStructureFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -16489,10 +22539,16 @@
void marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -16505,10 +22561,16 @@
void unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceAccelerationStructurePropertiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -16521,10 +22583,16 @@
void marshal_VkAccelerationStructureDeviceAddressInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -16532,10 +22600,16 @@
void unmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureDeviceAddressInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -16543,55 +22617,85 @@
void marshal_VkAccelerationStructureVersionInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureVersionInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
}
void unmarshal_VkAccelerationStructureVersionInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureVersionInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
}
void marshal_VkCopyAccelerationStructureToMemoryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
- marshal_VkDeviceOrHostAddressKHR(vkStream, (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst));
+ marshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst));
vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
}
void unmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyAccelerationStructureToMemoryInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->dst));
+ unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->dst));
vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
}
void marshal_VkCopyMemoryToAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->dst, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -16600,11 +22704,17 @@
void unmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyMemoryToAccelerationStructureInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->src));
+ 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));
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);
@@ -16613,10 +22723,16 @@
void marshal_VkCopyAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyAccelerationStructureInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -16628,10 +22744,16 @@
void unmarshal_VkCopyAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyAccelerationStructureInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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);
@@ -16643,10 +22765,16 @@
void marshal_VkAccelerationStructureBuildSizesInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceSize*)&forMarshaling->accelerationStructureSize, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->updateScratchSize, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->buildScratchSize, sizeof(VkDeviceSize));
@@ -16654,10 +22782,16 @@
void unmarshal_VkAccelerationStructureBuildSizesInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureBuildSizesInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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->updateScratchSize, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->buildScratchSize, sizeof(VkDeviceSize));
@@ -16667,10 +22801,16 @@
#ifdef VK_KHR_ray_tracing_pipeline
void marshal_VkRayTracingShaderGroupCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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((uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->closestHitShader, sizeof(uint32_t));
@@ -16687,10 +22827,16 @@
void unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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((uint32_t*)&forUnmarshaling->generalShader, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->closestHitShader, sizeof(uint32_t));
@@ -16711,37 +22857,55 @@
void marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayPayloadSize, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayHitAttributeSize, sizeof(uint32_t));
}
void unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayPayloadSize, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayHitAttributeSize, sizeof(uint32_t));
}
void marshal_VkRayTracingPipelineCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
@@ -16749,7 +22913,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i)
{
- marshal_VkRayTracingShaderGroupCreateInfoKHR(vkStream, (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i));
+ marshal_VkRayTracingShaderGroupCreateInfoKHR(vkStream, rootType, (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
@@ -16758,21 +22922,21 @@
vkStream->putBe64(cgen_var_0);
if (forMarshaling->pLibraryInfo)
{
- marshal_VkPipelineLibraryCreateInfoKHR(vkStream, (const VkPipelineLibraryCreateInfoKHR*)(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, (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(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, (const VkPipelineDynamicStateCreateInfo*)(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);
@@ -16785,17 +22949,23 @@
void unmarshal_VkRayTracingPipelineCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingPipelineCreateInfoKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
@@ -16803,7 +22973,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i)
{
- unmarshal_VkRayTracingShaderGroupCreateInfoKHR(vkStream, (VkRayTracingShaderGroupCreateInfoKHR*)(forUnmarshaling->pGroups + i));
+ unmarshal_VkRayTracingShaderGroupCreateInfoKHR(vkStream, rootType, (VkRayTracingShaderGroupCreateInfoKHR*)(forUnmarshaling->pGroups + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
@@ -16816,7 +22986,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pLibraryInfo inconsistent between guest and host\n");
}
- unmarshal_VkPipelineLibraryCreateInfoKHR(vkStream, (VkPipelineLibraryCreateInfoKHR*)(forUnmarshaling->pLibraryInfo));
+ unmarshal_VkPipelineLibraryCreateInfoKHR(vkStream, rootType, (VkPipelineLibraryCreateInfoKHR*)(forUnmarshaling->pLibraryInfo));
}
// WARNING PTR CHECK
const VkRayTracingPipelineInterfaceCreateInfoKHR* check_pLibraryInterface;
@@ -16827,7 +22997,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pLibraryInterface inconsistent between guest and host\n");
}
- unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(vkStream, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(forUnmarshaling->pLibraryInterface));
+ unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(vkStream, rootType, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(forUnmarshaling->pLibraryInterface));
}
// WARNING PTR CHECK
const VkPipelineDynamicStateCreateInfo* check_pDynamicState;
@@ -16838,7 +23008,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pDynamicState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
+ unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
}
uint64_t cgen_var_3;
vkStream->read((uint64_t*)&cgen_var_3, 1 * 8);
@@ -16851,10 +23021,16 @@
void marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ 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));
@@ -16864,10 +23040,16 @@
void unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ 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));
@@ -16877,10 +23059,16 @@
void marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleSize, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxRayRecursionDepth, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxShaderGroupStride, sizeof(uint32_t));
@@ -16893,10 +23081,16 @@
void unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleSize, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxRayRecursionDepth, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxShaderGroupStride, sizeof(uint32_t));
@@ -16909,8 +23103,10 @@
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));
@@ -16918,8 +23114,10 @@
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));
@@ -16927,8 +23125,10 @@
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));
@@ -16936,8 +23136,10 @@
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));
vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
@@ -16947,33 +23149,46 @@
#ifdef VK_KHR_ray_query
void marshal_VkPhysicalDeviceRayQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling)
{
+ (void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- marshal_extension_struct(vkStream, forMarshaling->pNext);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->rayQuery, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRayQueryFeaturesKHR* forUnmarshaling)
{
+ (void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->rayQuery, sizeof(VkBool32));
}
#endif
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(), 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, (void*)structAccess->pNext);
+ marshal_extension_struct(vkStream, rootType, (void*)structAccess->pNext);
return;
}
else
@@ -16997,1535 +23212,1613 @@
#ifdef VK_VERSION_1_1
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
{
- marshal_VkPhysicalDeviceSubgroupProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension));
+ marshal_VkPhysicalDeviceSubgroupProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
{
- marshal_VkPhysicalDevice16BitStorageFeatures(vkStream, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension));
+ marshal_VkPhysicalDevice16BitStorageFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
{
- marshal_VkMemoryDedicatedRequirements(vkStream, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension));
+ marshal_VkMemoryDedicatedRequirements(vkStream, rootType, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
{
- marshal_VkMemoryDedicatedAllocateInfo(vkStream, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension));
+ marshal_VkMemoryDedicatedAllocateInfo(vkStream, rootType, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
{
- marshal_VkMemoryAllocateFlagsInfo(vkStream, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension));
+ marshal_VkMemoryAllocateFlagsInfo(vkStream, rootType, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
{
- marshal_VkDeviceGroupRenderPassBeginInfo(vkStream, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension));
+ marshal_VkDeviceGroupRenderPassBeginInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
{
- marshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension));
+ marshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
{
- marshal_VkDeviceGroupSubmitInfo(vkStream, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension));
+ marshal_VkDeviceGroupSubmitInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
{
- marshal_VkDeviceGroupBindSparseInfo(vkStream, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension));
+ marshal_VkDeviceGroupBindSparseInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
{
- marshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension));
+ marshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
{
- marshal_VkBindImageMemoryDeviceGroupInfo(vkStream, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension));
+ marshal_VkBindImageMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
{
- marshal_VkDeviceGroupDeviceCreateInfo(vkStream, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension));
+ marshal_VkDeviceGroupDeviceCreateInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
{
- marshal_VkPhysicalDeviceFeatures2(vkStream, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension));
+ marshal_VkPhysicalDeviceFeatures2(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
{
- marshal_VkPhysicalDevicePointClippingProperties(vkStream, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension));
+ marshal_VkPhysicalDevicePointClippingProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
{
- marshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension));
+ marshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
{
- marshal_VkImageViewUsageCreateInfo(vkStream, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension));
+ marshal_VkImageViewUsageCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
{
- marshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension));
+ marshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, rootType, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
{
- marshal_VkRenderPassMultiviewCreateInfo(vkStream, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension));
+ marshal_VkRenderPassMultiviewCreateInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
{
- marshal_VkPhysicalDeviceMultiviewFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceMultiviewFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
{
- marshal_VkPhysicalDeviceMultiviewProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension));
+ marshal_VkPhysicalDeviceMultiviewProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
{
- marshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
{
- marshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
{
- marshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension));
+ marshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
{
- marshal_VkProtectedSubmitInfo(vkStream, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension));
+ marshal_VkProtectedSubmitInfo(vkStream, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
{
- marshal_VkSamplerYcbcrConversionInfo(vkStream, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension));
+ marshal_VkSamplerYcbcrConversionInfo(vkStream, rootType, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
{
- marshal_VkBindImagePlaneMemoryInfo(vkStream, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension));
+ marshal_VkBindImagePlaneMemoryInfo(vkStream, rootType, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
{
- marshal_VkImagePlaneMemoryRequirementsInfo(vkStream, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension));
+ marshal_VkImagePlaneMemoryRequirementsInfo(vkStream, rootType, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
{
- marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
{
- marshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension));
+ marshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, rootType, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
{
- marshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension));
+ marshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
{
- marshal_VkExternalImageFormatProperties(vkStream, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension));
+ marshal_VkExternalImageFormatProperties(vkStream, rootType, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
{
- marshal_VkPhysicalDeviceIDProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension));
+ marshal_VkPhysicalDeviceIDProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
{
- marshal_VkExternalMemoryImageCreateInfo(vkStream, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension));
+ marshal_VkExternalMemoryImageCreateInfo(vkStream, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
{
- marshal_VkExternalMemoryBufferCreateInfo(vkStream, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension));
+ marshal_VkExternalMemoryBufferCreateInfo(vkStream, rootType, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
{
- marshal_VkExportMemoryAllocateInfo(vkStream, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension));
+ marshal_VkExportMemoryAllocateInfo(vkStream, rootType, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
{
- marshal_VkExportFenceCreateInfo(vkStream, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension));
+ marshal_VkExportFenceCreateInfo(vkStream, rootType, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
{
- marshal_VkExportSemaphoreCreateInfo(vkStream, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension));
+ marshal_VkExportSemaphoreCreateInfo(vkStream, rootType, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
{
- marshal_VkPhysicalDeviceMaintenance3Properties(vkStream, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension));
+ marshal_VkPhysicalDeviceMaintenance3Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
{
- marshal_VkPhysicalDeviceShaderDrawParametersFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension));
+ marshal_VkPhysicalDeviceVulkan11Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
{
- marshal_VkPhysicalDeviceVulkan11Properties(vkStream, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension));
+ marshal_VkPhysicalDeviceVulkan11Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
{
- marshal_VkPhysicalDeviceVulkan12Features(vkStream, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension));
+ marshal_VkPhysicalDeviceVulkan12Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
{
- marshal_VkPhysicalDeviceVulkan12Properties(vkStream, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension));
+ marshal_VkPhysicalDeviceVulkan12Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
{
- marshal_VkImageFormatListCreateInfo(vkStream, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension));
+ marshal_VkImageFormatListCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
{
- marshal_VkPhysicalDevice8BitStorageFeatures(vkStream, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension));
+ marshal_VkPhysicalDevice8BitStorageFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
{
- marshal_VkPhysicalDeviceDriverProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension));
+ marshal_VkPhysicalDeviceDriverProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
{
- marshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension));
+ marshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
{
- marshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension));
+ marshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
{
- marshal_VkPhysicalDeviceFloatControlsProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension));
+ marshal_VkPhysicalDeviceFloatControlsProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
{
- marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkStream, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension));
+ marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkStream, rootType, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
{
- marshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
{
- marshal_VkPhysicalDeviceDescriptorIndexingProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension));
+ marshal_VkPhysicalDeviceDescriptorIndexingProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
{
- marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkStream, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension));
+ marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkStream, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
{
- marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkStream, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension));
+ marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkStream, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
{
- marshal_VkSubpassDescriptionDepthStencilResolve(vkStream, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension));
+ marshal_VkSubpassDescriptionDepthStencilResolve(vkStream, rootType, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
{
- marshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension));
+ marshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
{
- marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
{
- marshal_VkImageStencilUsageCreateInfo(vkStream, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension));
+ marshal_VkImageStencilUsageCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
{
- marshal_VkSamplerReductionModeCreateInfo(vkStream, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension));
+ marshal_VkSamplerReductionModeCreateInfo(vkStream, rootType, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
{
- marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension));
+ marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
{
- marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
{
- marshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
{
- marshal_VkFramebufferAttachmentsCreateInfo(vkStream, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension));
+ marshal_VkFramebufferAttachmentsCreateInfo(vkStream, rootType, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
{
- marshal_VkRenderPassAttachmentBeginInfo(vkStream, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension));
+ marshal_VkRenderPassAttachmentBeginInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
{
- marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
{
- marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
{
- marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
{
- marshal_VkAttachmentReferenceStencilLayout(vkStream, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension));
+ marshal_VkAttachmentReferenceStencilLayout(vkStream, rootType, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
{
- marshal_VkAttachmentDescriptionStencilLayout(vkStream, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension));
+ marshal_VkAttachmentDescriptionStencilLayout(vkStream, rootType, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
{
- marshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
{
- marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
{
- marshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension));
+ marshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
{
- marshal_VkSemaphoreTypeCreateInfo(vkStream, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension));
+ marshal_VkSemaphoreTypeCreateInfo(vkStream, rootType, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
{
- marshal_VkTimelineSemaphoreSubmitInfo(vkStream, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension));
+ marshal_VkTimelineSemaphoreSubmitInfo(vkStream, rootType, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
{
- marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension));
+ marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
{
- marshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension));
+ marshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, rootType, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
{
- marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(vkStream, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension));
+ 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, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension));
+ marshal_VkImageSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
{
- marshal_VkBindImageMemorySwapchainInfoKHR(vkStream, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension));
+ marshal_VkBindImageMemorySwapchainInfoKHR(vkStream, rootType, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
{
- marshal_VkDeviceGroupPresentInfoKHR(vkStream, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension));
+ marshal_VkDeviceGroupPresentInfoKHR(vkStream, rootType, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
{
- marshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension));
+ 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, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension));
+ marshal_VkDisplayPresentInfoKHR(vkStream, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- marshal_VkImportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension));
+ marshal_VkImportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- marshal_VkExportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension));
+ 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, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension));
+ 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, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension));
+ 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, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension));
+ marshal_VkExportSemaphoreWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
{
- marshal_VkD3D12FenceSubmitInfoKHR(vkStream, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension));
+ 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, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension));
+ 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, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension));
+ marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
{
- marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension));
+ marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
{
- marshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension));
+ marshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
{
- marshal_VkPerformanceQuerySubmitInfoKHR(vkStream, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension));
+ marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
{
- marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension));
+ 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, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension));
+ marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
{
- marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkStream, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension));
+ marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
{
- marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension));
+ 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, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension));
+ marshal_VkSurfaceProtectedCapabilitiesKHR(vkStream, rootType, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
{
- marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension));
+ marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
{
- marshal_VkNativeBufferANDROID(vkStream, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension));
+ 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, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension));
+ 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, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension));
+ marshal_VkDedicatedAllocationImageCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
{
- marshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension));
+ marshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
{
- marshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
{
- marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension));
+ marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
{
- marshal_VkTextureLODGatherFormatPropertiesAMD(vkStream, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension));
+ marshal_VkExternalMemoryImageCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
{
- marshal_VkExportMemoryAllocateInfoNV(vkStream, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension));
+ marshal_VkImportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
{
- marshal_VkExportMemoryWin32HandleInfoNV(vkStream, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension));
+ marshal_VkImageViewASTCDecodeModeEXT(vkStream, rootType, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
{
- marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
{
- marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
{
- marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
{
- marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension));
+ marshal_VkAndroidHardwareBufferUsageANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
{
- marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension));
+ marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
{
- marshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension));
+ marshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, rootType, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
{
- marshal_VkExternalFormatANDROID(vkStream, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension));
+ marshal_VkExternalFormatANDROID(vkStream, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
{
- marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
{
- marshal_VkWriteDescriptorSetInlineUniformBlockEXT(vkStream, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension));
+ 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, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension));
+ marshal_VkSampleLocationsInfoEXT(vkStream, rootType, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
{
- marshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension));
+ marshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
{
- marshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension));
+ marshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension));
+ marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
{
- marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension));
+ marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_validation_cache
case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
{
- marshal_VkShaderModuleValidationCacheCreateInfoEXT(vkStream, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension));
+ marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
{
- marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension));
+ marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
{
- marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension));
+ marshal_VkWriteDescriptorSetAccelerationStructureNV(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
{
- marshal_VkPhysicalDeviceRayTracingPropertiesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension));
+ marshal_VkImportMemoryHostPointerInfoEXT(vkStream, rootType, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension));
+ marshal_VkPhysicalDeviceShaderCorePropertiesAMD(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
{
- marshal_VkDeviceMemoryOverallocationCreateInfoAMD(vkStream, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension));
+ marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
{
- marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension));
+ marshal_VkPhysicalDeviceMeshShaderFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
{
- marshal_VkPhysicalDeviceMeshShaderPropertiesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension));
+ marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
{
- marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension));
+ 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, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension));
+ marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(vkStream, rootType, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
{
- marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(vkStream, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension));
+ marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(vkStream, rootType, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension));
break;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- marshal_VkImportColorBufferGOOGLE(vkStream, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension));
+ 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));
+ break;
+ }
+ 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));
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- marshal_VkImportBufferGOOGLE(vkStream, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension));
+ 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));
+ break;
+ }
+ default:
+ {
+ marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension));
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- marshal_VkImportPhysicalAddressGOOGLE(vkStream, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension));
+ 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));
+ break;
+ }
+ 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));
+ break;
+ }
+ }
break;
}
#endif
#ifdef VK_EXT_subgroup_size_control
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
{
- marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
{
- marshal_VkMemoryPriorityAllocateInfoEXT(vkStream, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
{
- marshal_VkBufferDeviceAddressCreateInfoEXT(vkStream, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension));
+ marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
{
- marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension));
+ marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
{
- marshal_VkPipelineCoverageReductionStateCreateInfoNV(vkStream, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
{
- marshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension));
+ marshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
{
- marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(vkStream, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension));
+ marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
{
- marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(vkStream, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
{
- marshal_VkPipelineRasterizationLineStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(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, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension));
+ marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
{
- marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension));
+ marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
{
- marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(vkStream, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension));
+ marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
{
- marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension));
+ 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, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
{
- marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(vkStream, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceRobustness2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceRobustness2PropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension));
+ marshal_VkSamplerCustomBorderColorCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
{
- marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension));
+ marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
{
- marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDevicePrivateDataFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
{
- marshal_VkDevicePrivateDataCreateInfoEXT(vkStream, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension));
+ marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
{
- marshal_VkDeviceDiagnosticsConfigCreateInfoNV(vkStream, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension));
+ 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, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension));
+ marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
{
- marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension));
+ marshal_VkPhysicalDevice4444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension));
+ break;
+ }
+#endif
+#ifdef VK_GOOGLE_gfxstream
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ {
+ marshal_VkImportPhysicalAddressGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
- marshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension));
+ marshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
{
- marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension));
+ marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
{
- marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension));
+ marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
{
- marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension));
+ 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, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension));
+ marshal_VkPhysicalDeviceRayQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension));
break;
}
#endif
@@ -18539,14 +24832,15 @@
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(), 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, (void*)structAccess->pNext);
+ unmarshal_extension_struct(vkStream, rootType, (void*)structAccess->pNext);
return;
}
else
@@ -18572,1535 +24866,1613 @@
#ifdef VK_VERSION_1_1
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceSubgroupProperties(vkStream, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceSubgroupProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
{
- unmarshal_VkPhysicalDevice16BitStorageFeatures(vkStream, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDevice16BitStorageFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
{
- unmarshal_VkMemoryDedicatedRequirements(vkStream, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ unmarshal_VkMemoryDedicatedRequirements(vkStream, rootType, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
{
- unmarshal_VkMemoryDedicatedAllocateInfo(vkStream, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ unmarshal_VkMemoryDedicatedAllocateInfo(vkStream, rootType, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
{
- unmarshal_VkMemoryAllocateFlagsInfo(vkStream, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ unmarshal_VkMemoryAllocateFlagsInfo(vkStream, rootType, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
{
- unmarshal_VkDeviceGroupRenderPassBeginInfo(vkStream, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ unmarshal_VkDeviceGroupRenderPassBeginInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
{
- unmarshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ unmarshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
{
- unmarshal_VkDeviceGroupSubmitInfo(vkStream, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ unmarshal_VkDeviceGroupSubmitInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
{
- unmarshal_VkDeviceGroupBindSparseInfo(vkStream, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ unmarshal_VkDeviceGroupBindSparseInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
{
- unmarshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ unmarshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
{
- unmarshal_VkBindImageMemoryDeviceGroupInfo(vkStream, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ unmarshal_VkBindImageMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
{
- unmarshal_VkDeviceGroupDeviceCreateInfo(vkStream, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ unmarshal_VkDeviceGroupDeviceCreateInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
{
- unmarshal_VkPhysicalDeviceFeatures2(vkStream, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceFeatures2(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
{
- unmarshal_VkPhysicalDevicePointClippingProperties(vkStream, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDevicePointClippingProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
{
- unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+ unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, rootType, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
{
- unmarshal_VkImageViewUsageCreateInfo(vkStream, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+ unmarshal_VkImageViewUsageCreateInfo(vkStream, rootType, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
{
- unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+ unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, rootType, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
{
- unmarshal_VkRenderPassMultiviewCreateInfo(vkStream, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ unmarshal_VkRenderPassMultiviewCreateInfo(vkStream, rootType, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
{
- unmarshal_VkPhysicalDeviceMultiviewFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceMultiviewFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceMultiviewProperties(vkStream, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceMultiviewProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
{
- unmarshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
{
- unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
{
- unmarshal_VkProtectedSubmitInfo(vkStream, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ unmarshal_VkProtectedSubmitInfo(vkStream, rootType, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
{
- unmarshal_VkSamplerYcbcrConversionInfo(vkStream, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ unmarshal_VkSamplerYcbcrConversionInfo(vkStream, rootType, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
{
- unmarshal_VkBindImagePlaneMemoryInfo(vkStream, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ unmarshal_VkBindImagePlaneMemoryInfo(vkStream, rootType, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
{
- unmarshal_VkImagePlaneMemoryRequirementsInfo(vkStream, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ unmarshal_VkImagePlaneMemoryRequirementsInfo(vkStream, rootType, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
{
- unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
{
- unmarshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ unmarshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, rootType, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
{
- unmarshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
{
- unmarshal_VkExternalImageFormatProperties(vkStream, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ unmarshal_VkExternalImageFormatProperties(vkStream, rootType, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceIDProperties(vkStream, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceIDProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
{
- unmarshal_VkExternalMemoryImageCreateInfo(vkStream, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ unmarshal_VkExternalMemoryImageCreateInfo(vkStream, rootType, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
{
- unmarshal_VkExternalMemoryBufferCreateInfo(vkStream, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ unmarshal_VkExternalMemoryBufferCreateInfo(vkStream, rootType, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
{
- unmarshal_VkExportMemoryAllocateInfo(vkStream, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ unmarshal_VkExportMemoryAllocateInfo(vkStream, rootType, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
{
- unmarshal_VkExportFenceCreateInfo(vkStream, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ unmarshal_VkExportFenceCreateInfo(vkStream, rootType, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
{
- unmarshal_VkExportSemaphoreCreateInfo(vkStream, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ unmarshal_VkExportSemaphoreCreateInfo(vkStream, rootType, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceMaintenance3Properties(vkStream, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceMaintenance3Properties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
{
- unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceVulkan11Features(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceVulkan11Properties(vkStream, reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceVulkan11Properties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
{
- unmarshal_VkPhysicalDeviceVulkan12Features(vkStream, reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceVulkan12Features(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceVulkan12Properties(vkStream, reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceVulkan12Properties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
{
- unmarshal_VkImageFormatListCreateInfo(vkStream, reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
+ unmarshal_VkImageFormatListCreateInfo(vkStream, rootType, reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
{
- unmarshal_VkPhysicalDevice8BitStorageFeatures(vkStream, reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDevice8BitStorageFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceDriverProperties(vkStream, reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDriverProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
{
- unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
{
- unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceFloatControlsProperties(vkStream, reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceFloatControlsProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
{
- unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkStream, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
+ unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkStream, rootType, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
{
- unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(vkStream, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
{
- unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkStream, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
+ unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkStream, rootType, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
{
- unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkStream, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
+ unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkStream, rootType, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
{
- unmarshal_VkSubpassDescriptionDepthStencilResolve(vkStream, reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
+ unmarshal_VkSubpassDescriptionDepthStencilResolve(vkStream, rootType, reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
{
- unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
{
- unmarshal_VkImageStencilUsageCreateInfo(vkStream, reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
+ unmarshal_VkImageStencilUsageCreateInfo(vkStream, rootType, reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
{
- unmarshal_VkSamplerReductionModeCreateInfo(vkStream, reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
+ unmarshal_VkSamplerReductionModeCreateInfo(vkStream, rootType, reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
{
- unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
{
- unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
{
- unmarshal_VkFramebufferAttachmentsCreateInfo(vkStream, reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
+ unmarshal_VkFramebufferAttachmentsCreateInfo(vkStream, rootType, reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
{
- unmarshal_VkRenderPassAttachmentBeginInfo(vkStream, reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
+ unmarshal_VkRenderPassAttachmentBeginInfo(vkStream, rootType, reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
{
- unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
{
- unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
{
- unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
{
- unmarshal_VkAttachmentReferenceStencilLayout(vkStream, reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
+ unmarshal_VkAttachmentReferenceStencilLayout(vkStream, rootType, reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
{
- unmarshal_VkAttachmentDescriptionStencilLayout(vkStream, reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
+ unmarshal_VkAttachmentDescriptionStencilLayout(vkStream, rootType, reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
{
- unmarshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
{
- unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
{
- unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
{
- unmarshal_VkSemaphoreTypeCreateInfo(vkStream, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
+ unmarshal_VkSemaphoreTypeCreateInfo(vkStream, rootType, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
{
- unmarshal_VkTimelineSemaphoreSubmitInfo(vkStream, reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
+ unmarshal_VkTimelineSemaphoreSubmitInfo(vkStream, rootType, reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
{
- unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
{
- unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
+ unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, rootType, reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
{
- unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(vkStream, reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
+ 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, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+ unmarshal_VkImageSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
{
- unmarshal_VkBindImageMemorySwapchainInfoKHR(vkStream, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ unmarshal_VkBindImageMemorySwapchainInfoKHR(vkStream, rootType, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
{
- unmarshal_VkDeviceGroupPresentInfoKHR(vkStream, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ unmarshal_VkDeviceGroupPresentInfoKHR(vkStream, rootType, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
{
- unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+ unmarshal_VkDisplayPresentInfoKHR(vkStream, rootType, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- unmarshal_VkImportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ unmarshal_VkImportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- unmarshal_VkExportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+ unmarshal_VkExportSemaphoreWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
{
- unmarshal_VkD3D12FenceSubmitInfoKHR(vkStream, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
+ unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
{
- unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
+ unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
{
- unmarshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
+ unmarshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, rootType, reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
{
- unmarshal_VkPerformanceQuerySubmitInfoKHR(vkStream, reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
+ unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
{
- unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(vkStream, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
+ unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkStream, rootType, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
{
- unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkStream, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
{
- unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkStream, reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
+ unmarshal_VkSurfaceProtectedCapabilitiesKHR(vkStream, rootType, reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
{
- unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
+ unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
{
- unmarshal_VkNativeBufferANDROID(vkStream, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+ 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, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+ 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, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+ unmarshal_VkDedicatedAllocationImageCreateInfoNV(vkStream, rootType, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
{
- unmarshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ unmarshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, rootType, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
{
- unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
{
- unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
+ unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
{
- unmarshal_VkTextureLODGatherFormatPropertiesAMD(vkStream, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+ unmarshal_VkExternalMemoryImageCreateInfoNV(vkStream, rootType, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
{
- unmarshal_VkExportMemoryAllocateInfoNV(vkStream, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+ unmarshal_VkImportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
{
- unmarshal_VkExportMemoryWin32HandleInfoNV(vkStream, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
+ unmarshal_VkImageViewASTCDecodeModeEXT(vkStream, rootType, reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
{
- unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
{
- unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
{
- unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
{
- unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+ unmarshal_VkAndroidHardwareBufferUsageANDROID(vkStream, rootType, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
{
- unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, rootType, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
{
- unmarshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ unmarshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, rootType, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
{
- unmarshal_VkExternalFormatANDROID(vkStream, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ unmarshal_VkExternalFormatANDROID(vkStream, rootType, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
{
- unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
{
- unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(vkStream, reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+ unmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
{
- unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+ unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, rootType, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
{
- unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+ unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
{
- unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(vkStream, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
+ unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_cache
case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
{
- unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(vkStream, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
+ unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
{
- unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(vkStream, reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
{
- unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(vkStream, reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
+ unmarshal_VkWriteDescriptorSetAccelerationStructureNV(vkStream, rootType, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
{
- unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(vkStream, reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ unmarshal_VkImportMemoryHostPointerInfoEXT(vkStream, rootType, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
{
- unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(vkStream, reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+ unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
{
- unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
{
- unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(vkStream, reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
+ unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
{
- unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(vkStream, reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension_out));
+ 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, reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
+ unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(vkStream, rootType, reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
{
- unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(vkStream, reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
+ unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(vkStream, rootType, reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
break;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- unmarshal_VkImportColorBufferGOOGLE(vkStream, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ 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));
+ break;
+ }
+ 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));
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- unmarshal_VkImportBufferGOOGLE(vkStream, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ 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));
+ break;
+ }
+ default:
+ {
+ unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- unmarshal_VkImportPhysicalAddressGOOGLE(vkStream, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ 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));
+ break;
+ }
+ 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));
+ break;
+ }
+ }
break;
}
#endif
#ifdef VK_EXT_subgroup_size_control
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
{
- unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
{
- unmarshal_VkMemoryPriorityAllocateInfoEXT(vkStream, reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
{
- unmarshal_VkBufferDeviceAddressCreateInfoEXT(vkStream, reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
{
- unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(vkStream, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
{
- unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(vkStream, reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
{
- unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
+ unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, rootType, reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
{
- unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(vkStream, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
+ unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(vkStream, rootType, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
{
- unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(vkStream, reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
{
- unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(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, reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
{
- unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(vkStream, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
{
- unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(vkStream, reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
+ unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(vkStream, rootType, reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
{
- unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
+ 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, reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
{
- unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(vkStream, reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
+ unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
{
- unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
{
- unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
{
- unmarshal_VkDevicePrivateDataCreateInfoEXT(vkStream, reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
{
- unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(vkStream, reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension_out));
+ 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, reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
+ unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(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, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
+ unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(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));
+ break;
+ }
+ 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));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
- unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
+ unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, rootType, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
{
- unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
{
- unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(vkStream, reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
{
- unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(vkStream, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension_out));
+ 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, reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
+ unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
break;
}
#endif
@@ -21468,8 +27840,6 @@
{
return "OP_vkMapMemoryIntoAddressSpaceGOOGLE";
}
-#endif
-#ifdef VK_GOOGLE_color_buffer
case OP_vkRegisterImageColorBufferGOOGLE:
{
return "OP_vkRegisterImageColorBufferGOOGLE";
@@ -21478,8 +27848,6 @@
{
return "OP_vkRegisterBufferColorBufferGOOGLE";
}
-#endif
-#ifdef VK_GOOGLE_gfxstream
case OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE:
{
return "OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE";
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
index 68ea1a6..86c6b4e 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -46,218 +46,272 @@
#ifdef VK_VERSION_1_0
void marshal_VkExtent2D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExtent2D* forMarshaling);
void unmarshal_VkExtent2D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExtent2D* forUnmarshaling);
void marshal_VkExtent3D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExtent3D* forMarshaling);
void unmarshal_VkExtent3D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExtent3D* forUnmarshaling);
void marshal_VkOffset2D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkOffset2D* forMarshaling);
void unmarshal_VkOffset2D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkOffset2D* forUnmarshaling);
void marshal_VkOffset3D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkOffset3D* forMarshaling);
void unmarshal_VkOffset3D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkOffset3D* forUnmarshaling);
void marshal_VkRect2D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRect2D* forMarshaling);
void unmarshal_VkRect2D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRect2D* forUnmarshaling);
void marshal_VkBaseInStructure(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBaseInStructure* forMarshaling);
void unmarshal_VkBaseInStructure(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBaseInStructure* forUnmarshaling);
void marshal_VkBaseOutStructure(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBaseOutStructure* forMarshaling);
void unmarshal_VkBaseOutStructure(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBaseOutStructure* forUnmarshaling);
void marshal_VkBufferMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferMemoryBarrier* forMarshaling);
void unmarshal_VkBufferMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferMemoryBarrier* forUnmarshaling);
void marshal_VkDispatchIndirectCommand(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDispatchIndirectCommand* forMarshaling);
void unmarshal_VkDispatchIndirectCommand(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDispatchIndirectCommand* forUnmarshaling);
void marshal_VkDrawIndexedIndirectCommand(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrawIndexedIndirectCommand* forMarshaling);
void unmarshal_VkDrawIndexedIndirectCommand(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDrawIndexedIndirectCommand* forUnmarshaling);
void marshal_VkDrawIndirectCommand(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrawIndirectCommand* forMarshaling);
void unmarshal_VkDrawIndirectCommand(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDrawIndirectCommand* forUnmarshaling);
void marshal_VkImageSubresourceRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSubresourceRange* forMarshaling);
void unmarshal_VkImageSubresourceRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageSubresourceRange* forUnmarshaling);
void marshal_VkImageMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageMemoryBarrier* forMarshaling);
void unmarshal_VkImageMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageMemoryBarrier* forUnmarshaling);
void marshal_VkMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryBarrier* forMarshaling);
void unmarshal_VkMemoryBarrier(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryBarrier* forUnmarshaling);
void marshal_VkAllocationCallbacks(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAllocationCallbacks* forMarshaling);
void unmarshal_VkAllocationCallbacks(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAllocationCallbacks* forUnmarshaling);
void marshal_VkApplicationInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkApplicationInfo* forMarshaling);
void unmarshal_VkApplicationInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkApplicationInfo* forUnmarshaling);
void marshal_VkFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFormatProperties* forMarshaling);
void unmarshal_VkFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFormatProperties* forUnmarshaling);
void marshal_VkImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageFormatProperties* forMarshaling);
void unmarshal_VkImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageFormatProperties* forUnmarshaling);
void marshal_VkInstanceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkInstanceCreateInfo* forMarshaling);
void unmarshal_VkInstanceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkInstanceCreateInfo* forUnmarshaling);
void marshal_VkMemoryHeap(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryHeap* forMarshaling);
void unmarshal_VkMemoryHeap(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryHeap* forUnmarshaling);
void marshal_VkMemoryType(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryType* forMarshaling);
void unmarshal_VkMemoryType(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryType* forUnmarshaling);
void marshal_VkPhysicalDeviceFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceLimits(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLimits* forMarshaling);
void unmarshal_VkPhysicalDeviceLimits(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceLimits* forUnmarshaling);
void marshal_VkPhysicalDeviceMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMemoryProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceSparseProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceSparseProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSparseProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceProperties* forUnmarshaling);
void marshal_VkQueueFamilyProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueueFamilyProperties* forMarshaling);
void unmarshal_VkQueueFamilyProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueueFamilyProperties* forUnmarshaling);
#define OP_vkCreateInstance 20000
@@ -273,48 +327,58 @@
#define OP_vkGetDeviceProcAddr 20010
void marshal_VkDeviceQueueCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceQueueCreateInfo* forMarshaling);
void unmarshal_VkDeviceQueueCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceQueueCreateInfo* forUnmarshaling);
void marshal_VkDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceCreateInfo* forMarshaling);
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 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 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 unmarshal_VkSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubmitInfo* forUnmarshaling);
#define OP_vkGetDeviceQueue 20017
@@ -323,18 +387,22 @@
#define OP_vkDeviceWaitIdle 20020
void marshal_VkMappedMemoryRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMappedMemoryRange* forMarshaling);
void unmarshal_VkMappedMemoryRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMappedMemoryRange* forUnmarshaling);
void marshal_VkMemoryAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryAllocateInfo* forMarshaling);
void unmarshal_VkMemoryAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryAllocateInfo* forUnmarshaling);
#define OP_vkAllocateMemory 20021
@@ -346,10 +414,12 @@
#define OP_vkGetDeviceMemoryCommitment 20027
void marshal_VkMemoryRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryRequirements* forMarshaling);
void unmarshal_VkMemoryRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryRequirements* forUnmarshaling);
#define OP_vkBindBufferMemory 20028
@@ -358,74 +428,92 @@
#define OP_vkGetImageMemoryRequirements 20031
void marshal_VkSparseMemoryBind(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseMemoryBind* forMarshaling);
void unmarshal_VkSparseMemoryBind(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseMemoryBind* forUnmarshaling);
void marshal_VkSparseBufferMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseBufferMemoryBindInfo* forMarshaling);
void unmarshal_VkSparseBufferMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseBufferMemoryBindInfo* forUnmarshaling);
void marshal_VkSparseImageOpaqueMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageOpaqueMemoryBindInfo* forMarshaling);
void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling);
void marshal_VkImageSubresource(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSubresource* forMarshaling);
void unmarshal_VkImageSubresource(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageSubresource* forUnmarshaling);
void marshal_VkSparseImageMemoryBind(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryBind* forMarshaling);
void unmarshal_VkSparseImageMemoryBind(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageMemoryBind* forUnmarshaling);
void marshal_VkSparseImageMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryBindInfo* forMarshaling);
void unmarshal_VkSparseImageMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageMemoryBindInfo* forUnmarshaling);
void marshal_VkBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindSparseInfo* forMarshaling);
void unmarshal_VkBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindSparseInfo* forUnmarshaling);
void marshal_VkSparseImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageFormatProperties* forMarshaling);
void unmarshal_VkSparseImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageFormatProperties* forUnmarshaling);
void marshal_VkSparseImageMemoryRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements* forMarshaling);
void unmarshal_VkSparseImageMemoryRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageMemoryRequirements* forUnmarshaling);
#define OP_vkGetImageSparseMemoryRequirements 20032
@@ -433,10 +521,12 @@
#define OP_vkQueueBindSparse 20034
void marshal_VkFenceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFenceCreateInfo* forMarshaling);
void unmarshal_VkFenceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFenceCreateInfo* forUnmarshaling);
#define OP_vkCreateFence 20035
@@ -446,20 +536,24 @@
#define OP_vkWaitForFences 20039
void marshal_VkSemaphoreCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreCreateInfo* forMarshaling);
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 unmarshal_VkEventCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkEventCreateInfo* forUnmarshaling);
#define OP_vkCreateEvent 20042
@@ -469,10 +563,12 @@
#define OP_vkResetEvent 20046
void marshal_VkQueryPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolCreateInfo* forMarshaling);
void unmarshal_VkQueryPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueryPoolCreateInfo* forUnmarshaling);
#define OP_vkCreateQueryPool 20047
@@ -480,38 +576,46 @@
#define OP_vkGetQueryPoolResults 20049
void marshal_VkBufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferCreateInfo* forMarshaling);
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 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 unmarshal_VkImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageCreateInfo* forUnmarshaling);
void marshal_VkSubresourceLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubresourceLayout* forMarshaling);
void unmarshal_VkSubresourceLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubresourceLayout* forUnmarshaling);
#define OP_vkCreateImage 20054
@@ -519,38 +623,46 @@
#define OP_vkGetImageSubresourceLayout 20056
void marshal_VkComponentMapping(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkComponentMapping* forMarshaling);
void unmarshal_VkComponentMapping(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkComponentMapping* forUnmarshaling);
void marshal_VkImageViewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewCreateInfo* forMarshaling);
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 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 unmarshal_VkPipelineCacheCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCacheCreateInfo* forUnmarshaling);
#define OP_vkCreatePipelineCache 20061
@@ -559,154 +671,192 @@
#define OP_vkMergePipelineCaches 20064
void marshal_VkSpecializationMapEntry(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSpecializationMapEntry* forMarshaling);
void unmarshal_VkSpecializationMapEntry(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSpecializationMapEntry* forUnmarshaling);
void marshal_VkSpecializationInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSpecializationInfo* forMarshaling);
void unmarshal_VkSpecializationInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSpecializationInfo* forUnmarshaling);
void marshal_VkPipelineShaderStageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineShaderStageCreateInfo* forMarshaling);
void unmarshal_VkPipelineShaderStageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineShaderStageCreateInfo* forUnmarshaling);
void marshal_VkComputePipelineCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkComputePipelineCreateInfo* forMarshaling);
void unmarshal_VkComputePipelineCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkComputePipelineCreateInfo* forUnmarshaling);
void marshal_VkVertexInputBindingDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputBindingDescription* forMarshaling);
void unmarshal_VkVertexInputBindingDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkVertexInputBindingDescription* forUnmarshaling);
void marshal_VkVertexInputAttributeDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputAttributeDescription* forMarshaling);
void unmarshal_VkVertexInputAttributeDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkVertexInputAttributeDescription* forUnmarshaling);
void marshal_VkPipelineVertexInputStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineVertexInputStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineVertexInputStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineVertexInputStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineInputAssemblyStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineInputAssemblyStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineTessellationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineTessellationStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineTessellationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineTessellationStateCreateInfo* forUnmarshaling);
void marshal_VkViewport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkViewport* forMarshaling);
void unmarshal_VkViewport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkViewport* forUnmarshaling);
void marshal_VkPipelineViewportStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineViewportStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineRasterizationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineRasterizationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineMultisampleStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineMultisampleStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineMultisampleStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineMultisampleStateCreateInfo* forUnmarshaling);
void marshal_VkStencilOpState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStencilOpState* forMarshaling);
void unmarshal_VkStencilOpState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkStencilOpState* forUnmarshaling);
void marshal_VkPipelineDepthStencilStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDepthStencilStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineDepthStencilStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineDepthStencilStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineColorBlendAttachmentState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendAttachmentState* forMarshaling);
void unmarshal_VkPipelineColorBlendAttachmentState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineColorBlendAttachmentState* forUnmarshaling);
void marshal_VkPipelineColorBlendStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineColorBlendStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineColorBlendStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineDynamicStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDynamicStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineDynamicStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineDynamicStateCreateInfo* forUnmarshaling);
void marshal_VkGraphicsPipelineCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsPipelineCreateInfo* forMarshaling);
void unmarshal_VkGraphicsPipelineCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGraphicsPipelineCreateInfo* forUnmarshaling);
#define OP_vkCreateGraphicsPipelines 20065
@@ -714,102 +864,126 @@
#define OP_vkDestroyPipeline 20067
void marshal_VkPushConstantRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPushConstantRange* forMarshaling);
void unmarshal_VkPushConstantRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPushConstantRange* forUnmarshaling);
void marshal_VkPipelineLayoutCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineLayoutCreateInfo* forMarshaling);
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 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 unmarshal_VkCopyDescriptorSet(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyDescriptorSet* forUnmarshaling);
void marshal_VkDescriptorBufferInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorBufferInfo* forMarshaling);
void unmarshal_VkDescriptorBufferInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorBufferInfo* forUnmarshaling);
void marshal_VkDescriptorImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorImageInfo* forMarshaling);
void unmarshal_VkDescriptorImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorImageInfo* forUnmarshaling);
void marshal_VkDescriptorPoolSize(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorPoolSize* forMarshaling);
void unmarshal_VkDescriptorPoolSize(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorPoolSize* forUnmarshaling);
void marshal_VkDescriptorPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorPoolCreateInfo* forMarshaling);
void unmarshal_VkDescriptorPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorPoolCreateInfo* forUnmarshaling);
void marshal_VkDescriptorSetAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetAllocateInfo* forMarshaling);
void unmarshal_VkDescriptorSetAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetAllocateInfo* forUnmarshaling);
void marshal_VkDescriptorSetLayoutBinding(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBinding* forMarshaling);
void unmarshal_VkDescriptorSetLayoutBinding(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetLayoutBinding* forUnmarshaling);
void marshal_VkDescriptorSetLayoutCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutCreateInfo* forMarshaling);
void unmarshal_VkDescriptorSetLayoutCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetLayoutCreateInfo* forUnmarshaling);
void marshal_VkWriteDescriptorSet(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSet* forMarshaling);
void unmarshal_VkWriteDescriptorSet(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWriteDescriptorSet* forUnmarshaling);
#define OP_vkCreateDescriptorSetLayout 20072
@@ -822,50 +996,62 @@
#define OP_vkUpdateDescriptorSets 20079
void marshal_VkAttachmentDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentDescription* forMarshaling);
void unmarshal_VkAttachmentDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentDescription* forUnmarshaling);
void marshal_VkAttachmentReference(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentReference* forMarshaling);
void unmarshal_VkAttachmentReference(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentReference* forUnmarshaling);
void marshal_VkFramebufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferCreateInfo* forMarshaling);
void unmarshal_VkFramebufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFramebufferCreateInfo* forUnmarshaling);
void marshal_VkSubpassDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDescription* forMarshaling);
void unmarshal_VkSubpassDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassDescription* forUnmarshaling);
void marshal_VkSubpassDependency(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDependency* forMarshaling);
void unmarshal_VkSubpassDependency(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassDependency* forUnmarshaling);
void marshal_VkRenderPassCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassCreateInfo* forMarshaling);
void unmarshal_VkRenderPassCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassCreateInfo* forUnmarshaling);
#define OP_vkCreateFramebuffer 20080
@@ -875,10 +1061,12 @@
#define OP_vkGetRenderAreaGranularity 20084
void marshal_VkCommandPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandPoolCreateInfo* forMarshaling);
void unmarshal_VkCommandPoolCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandPoolCreateInfo* forUnmarshaling);
#define OP_vkCreateCommandPool 20085
@@ -886,26 +1074,32 @@
#define OP_vkResetCommandPool 20087
void marshal_VkCommandBufferAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferAllocateInfo* forMarshaling);
void unmarshal_VkCommandBufferAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferAllocateInfo* forUnmarshaling);
void marshal_VkCommandBufferInheritanceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceInfo* forMarshaling);
void unmarshal_VkCommandBufferInheritanceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferInheritanceInfo* forUnmarshaling);
void marshal_VkCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferBeginInfo* forMarshaling);
void unmarshal_VkCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferBeginInfo* forUnmarshaling);
#define OP_vkAllocateCommandBuffers 20088
@@ -915,98 +1109,122 @@
#define OP_vkResetCommandBuffer 20092
void marshal_VkBufferCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferCopy* forMarshaling);
void unmarshal_VkBufferCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferCopy* forUnmarshaling);
void marshal_VkImageSubresourceLayers(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSubresourceLayers* forMarshaling);
void unmarshal_VkImageSubresourceLayers(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageSubresourceLayers* forUnmarshaling);
void marshal_VkBufferImageCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferImageCopy* forMarshaling);
void unmarshal_VkBufferImageCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferImageCopy* forUnmarshaling);
void marshal_VkClearColorValue(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkClearColorValue* forMarshaling);
void unmarshal_VkClearColorValue(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkClearColorValue* forUnmarshaling);
void marshal_VkClearDepthStencilValue(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkClearDepthStencilValue* forMarshaling);
void unmarshal_VkClearDepthStencilValue(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkClearDepthStencilValue* forUnmarshaling);
void marshal_VkClearValue(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkClearValue* forMarshaling);
void unmarshal_VkClearValue(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkClearValue* forUnmarshaling);
void marshal_VkClearAttachment(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkClearAttachment* forMarshaling);
void unmarshal_VkClearAttachment(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkClearAttachment* forUnmarshaling);
void marshal_VkClearRect(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkClearRect* forMarshaling);
void unmarshal_VkClearRect(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkClearRect* forUnmarshaling);
void marshal_VkImageBlit(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageBlit* forMarshaling);
void unmarshal_VkImageBlit(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageBlit* forUnmarshaling);
void marshal_VkImageCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageCopy* forMarshaling);
void unmarshal_VkImageCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageCopy* forUnmarshaling);
void marshal_VkImageResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageResolve* forMarshaling);
void unmarshal_VkImageResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageResolve* forUnmarshaling);
void marshal_VkRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassBeginInfo* forMarshaling);
void unmarshal_VkRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassBeginInfo* forUnmarshaling);
#define OP_vkCmdBindPipeline 20093
@@ -1058,92 +1276,114 @@
#define OP_vkEnumerateInstanceVersion 20137
void marshal_VkPhysicalDeviceSubgroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceSubgroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSubgroupProperties* forUnmarshaling);
void marshal_VkBindBufferMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindBufferMemoryInfo* forMarshaling);
void unmarshal_VkBindBufferMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindBufferMemoryInfo* forUnmarshaling);
void marshal_VkBindImageMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemoryInfo* forMarshaling);
void unmarshal_VkBindImageMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindImageMemoryInfo* forUnmarshaling);
#define OP_vkBindBufferMemory2 20138
#define OP_vkBindImageMemory2 20139
void marshal_VkPhysicalDevice16BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice16BitStorageFeatures* forMarshaling);
void unmarshal_VkPhysicalDevice16BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevice16BitStorageFeatures* forUnmarshaling);
void marshal_VkMemoryDedicatedRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryDedicatedRequirements* forMarshaling);
void unmarshal_VkMemoryDedicatedRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryDedicatedRequirements* forUnmarshaling);
void marshal_VkMemoryDedicatedAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryDedicatedAllocateInfo* forMarshaling);
void unmarshal_VkMemoryDedicatedAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryDedicatedAllocateInfo* forUnmarshaling);
void marshal_VkMemoryAllocateFlagsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryAllocateFlagsInfo* forMarshaling);
void unmarshal_VkMemoryAllocateFlagsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryAllocateFlagsInfo* forUnmarshaling);
void marshal_VkDeviceGroupRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupRenderPassBeginInfo* forMarshaling);
void unmarshal_VkDeviceGroupRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupRenderPassBeginInfo* forUnmarshaling);
void marshal_VkDeviceGroupCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupCommandBufferBeginInfo* forMarshaling);
void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling);
void marshal_VkDeviceGroupSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupSubmitInfo* forMarshaling);
void unmarshal_VkDeviceGroupSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupSubmitInfo* forUnmarshaling);
void marshal_VkDeviceGroupBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupBindSparseInfo* forMarshaling);
void unmarshal_VkDeviceGroupBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupBindSparseInfo* forUnmarshaling);
#define OP_vkGetDeviceGroupPeerMemoryFeatures 20140
@@ -1151,75 +1391,93 @@
#define OP_vkCmdDispatchBase 20142
void marshal_VkBindBufferMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindBufferMemoryDeviceGroupInfo* forMarshaling);
void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling);
void marshal_VkBindImageMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemoryDeviceGroupInfo* forMarshaling);
void unmarshal_VkBindImageMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindImageMemoryDeviceGroupInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceGroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceGroupProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceGroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceGroupProperties* forUnmarshaling);
void marshal_VkDeviceGroupDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupDeviceCreateInfo* forMarshaling);
void unmarshal_VkDeviceGroupDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupDeviceCreateInfo* forUnmarshaling);
#define OP_vkEnumeratePhysicalDeviceGroups 20143
void marshal_VkBufferMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferMemoryRequirementsInfo2* forMarshaling);
void unmarshal_VkBufferMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferMemoryRequirementsInfo2* forUnmarshaling);
void marshal_VkImageMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageMemoryRequirementsInfo2* forMarshaling);
void unmarshal_VkImageMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageMemoryRequirementsInfo2* forUnmarshaling);
void marshal_VkImageSparseMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSparseMemoryRequirementsInfo2* forMarshaling);
void unmarshal_VkImageSparseMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageSparseMemoryRequirementsInfo2* forUnmarshaling);
void marshal_VkMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryRequirements2* forMarshaling);
void unmarshal_VkMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryRequirements2* forUnmarshaling);
void marshal_VkSparseImageMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements2* forMarshaling);
void unmarshal_VkSparseImageMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageMemoryRequirements2* forUnmarshaling);
#define OP_vkGetImageMemoryRequirements2 20144
@@ -1227,74 +1485,92 @@
#define OP_vkGetImageSparseMemoryRequirements2 20146
void marshal_VkPhysicalDeviceFeatures2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures2* forMarshaling);
void unmarshal_VkPhysicalDeviceFeatures2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFeatures2* forUnmarshaling);
void marshal_VkPhysicalDeviceProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProperties2* forMarshaling);
void unmarshal_VkPhysicalDeviceProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceProperties2* forUnmarshaling);
void marshal_VkFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFormatProperties2* forMarshaling);
void unmarshal_VkFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFormatProperties2* forUnmarshaling);
void marshal_VkImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageFormatProperties2* forMarshaling);
void unmarshal_VkImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageFormatProperties2* forUnmarshaling);
void marshal_VkPhysicalDeviceImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageFormatInfo2* forMarshaling);
void unmarshal_VkPhysicalDeviceImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImageFormatInfo2* forUnmarshaling);
void marshal_VkQueueFamilyProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueueFamilyProperties2* forMarshaling);
void unmarshal_VkQueueFamilyProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueueFamilyProperties2* forUnmarshaling);
void marshal_VkPhysicalDeviceMemoryProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties2* forMarshaling);
void unmarshal_VkPhysicalDeviceMemoryProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMemoryProperties2* forUnmarshaling);
void marshal_VkSparseImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageFormatProperties2* forMarshaling);
void unmarshal_VkSparseImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSparseImageFormatProperties2* forUnmarshaling);
void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling);
void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling);
#define OP_vkGetPhysicalDeviceFeatures2 20147
@@ -1307,74 +1583,92 @@
#define OP_vkTrimCommandPool 20154
void marshal_VkPhysicalDevicePointClippingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePointClippingProperties* forMarshaling);
void unmarshal_VkPhysicalDevicePointClippingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePointClippingProperties* forUnmarshaling);
void marshal_VkInputAttachmentAspectReference(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkInputAttachmentAspectReference* forMarshaling);
void unmarshal_VkInputAttachmentAspectReference(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkInputAttachmentAspectReference* forUnmarshaling);
void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling);
void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling);
void marshal_VkImageViewUsageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewUsageCreateInfo* forMarshaling);
void unmarshal_VkImageViewUsageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageViewUsageCreateInfo* forUnmarshaling);
void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling);
void marshal_VkRenderPassMultiviewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassMultiviewCreateInfo* forMarshaling);
void unmarshal_VkRenderPassMultiviewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassMultiviewCreateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceMultiviewFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceMultiviewFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMultiviewFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceMultiviewProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceMultiviewProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMultiviewProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceVariablePointersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceVariablePointersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVariablePointersFeatures* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVariablePointersFeatures, marshal_VkPhysicalDeviceVariablePointerFeatures);
@@ -1383,101 +1677,125 @@
void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceProtectedMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling);
void marshal_VkDeviceQueueInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceQueueInfo2* forMarshaling);
void unmarshal_VkDeviceQueueInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceQueueInfo2* forUnmarshaling);
void marshal_VkProtectedSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkProtectedSubmitInfo* forMarshaling);
void unmarshal_VkProtectedSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkProtectedSubmitInfo* forUnmarshaling);
#define OP_vkGetDeviceQueue2 20155
void marshal_VkSamplerYcbcrConversionCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionCreateInfo* forMarshaling);
void unmarshal_VkSamplerYcbcrConversionCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerYcbcrConversionCreateInfo* forUnmarshaling);
void marshal_VkSamplerYcbcrConversionInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionInfo* forMarshaling);
void unmarshal_VkSamplerYcbcrConversionInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerYcbcrConversionInfo* forUnmarshaling);
void marshal_VkBindImagePlaneMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImagePlaneMemoryInfo* forMarshaling);
void unmarshal_VkBindImagePlaneMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindImagePlaneMemoryInfo* forUnmarshaling);
void marshal_VkImagePlaneMemoryRequirementsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImagePlaneMemoryRequirementsInfo* forMarshaling);
void unmarshal_VkImagePlaneMemoryRequirementsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImagePlaneMemoryRequirementsInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling);
void marshal_VkSamplerYcbcrConversionImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling);
void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
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 unmarshal_VkDescriptorUpdateTemplateEntry(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorUpdateTemplateEntry* forUnmarshaling);
void marshal_VkDescriptorUpdateTemplateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateCreateInfo* forMarshaling);
void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling);
#define OP_vkCreateDescriptorUpdateTemplate 20158
@@ -1485,150 +1803,186 @@
#define OP_vkUpdateDescriptorSetWithTemplate 20160
void marshal_VkExternalMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryProperties* forMarshaling);
void unmarshal_VkExternalMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalMemoryProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalImageFormatInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling);
void marshal_VkExternalImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalImageFormatProperties* forMarshaling);
void unmarshal_VkExternalImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalImageFormatProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalBufferInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalBufferInfo* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalBufferInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalBufferInfo* forUnmarshaling);
void marshal_VkExternalBufferProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalBufferProperties* forMarshaling);
void unmarshal_VkExternalBufferProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalBufferProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceIDProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceIDProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceIDProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceIDProperties* forUnmarshaling);
#define OP_vkGetPhysicalDeviceExternalBufferProperties 20161
void marshal_VkExternalMemoryImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfo* forMarshaling);
void unmarshal_VkExternalMemoryImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalMemoryImageCreateInfo* forUnmarshaling);
void marshal_VkExternalMemoryBufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryBufferCreateInfo* forMarshaling);
void unmarshal_VkExternalMemoryBufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalMemoryBufferCreateInfo* forUnmarshaling);
void marshal_VkExportMemoryAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfo* forMarshaling);
void unmarshal_VkExportMemoryAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportMemoryAllocateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalFenceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalFenceInfo* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalFenceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalFenceInfo* forUnmarshaling);
void marshal_VkExternalFenceProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalFenceProperties* forMarshaling);
void unmarshal_VkExternalFenceProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalFenceProperties* forUnmarshaling);
#define OP_vkGetPhysicalDeviceExternalFenceProperties 20162
void marshal_VkExportFenceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportFenceCreateInfo* forMarshaling);
void unmarshal_VkExportFenceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportFenceCreateInfo* forUnmarshaling);
void marshal_VkExportSemaphoreCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportSemaphoreCreateInfo* forMarshaling);
void unmarshal_VkExportSemaphoreCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportSemaphoreCreateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling);
void marshal_VkExternalSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalSemaphoreProperties* forMarshaling);
void unmarshal_VkExternalSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalSemaphoreProperties* forUnmarshaling);
#define OP_vkGetPhysicalDeviceExternalSemaphoreProperties 20163
void marshal_VkPhysicalDeviceMaintenance3Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMaintenance3Properties* forMarshaling);
void unmarshal_VkPhysicalDeviceMaintenance3Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMaintenance3Properties* forUnmarshaling);
void marshal_VkDescriptorSetLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutSupport* forMarshaling);
void unmarshal_VkDescriptorSetLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetLayoutSupport* forUnmarshaling);
#define OP_vkGetDescriptorSetLayoutSupport 20164
void marshal_VkPhysicalDeviceShaderDrawParametersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderDrawParametersFeatures* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderDrawParametersFeatures, marshal_VkPhysicalDeviceShaderDrawParameterFeatures);
@@ -1639,108 +1993,134 @@
#ifdef VK_VERSION_1_2
void marshal_VkPhysicalDeviceVulkan11Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Features* forMarshaling);
void unmarshal_VkPhysicalDeviceVulkan11Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkan11Features* forUnmarshaling);
void marshal_VkPhysicalDeviceVulkan11Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Properties* forMarshaling);
void unmarshal_VkPhysicalDeviceVulkan11Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkan11Properties* forUnmarshaling);
void marshal_VkPhysicalDeviceVulkan12Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Features* forMarshaling);
void unmarshal_VkPhysicalDeviceVulkan12Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkan12Features* forUnmarshaling);
void marshal_VkConformanceVersion(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkConformanceVersion* forMarshaling);
void unmarshal_VkConformanceVersion(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkConformanceVersion* forUnmarshaling);
void marshal_VkPhysicalDeviceVulkan12Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Properties* forMarshaling);
void unmarshal_VkPhysicalDeviceVulkan12Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkan12Properties* forUnmarshaling);
void marshal_VkImageFormatListCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageFormatListCreateInfo* forMarshaling);
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 unmarshal_VkAttachmentDescription2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentDescription2* forUnmarshaling);
void marshal_VkAttachmentReference2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentReference2* forMarshaling);
void unmarshal_VkAttachmentReference2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentReference2* forUnmarshaling);
void marshal_VkSubpassDescription2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDescription2* forMarshaling);
void unmarshal_VkSubpassDescription2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassDescription2* forUnmarshaling);
void marshal_VkSubpassDependency2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDependency2* forMarshaling);
void unmarshal_VkSubpassDependency2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassDependency2* forUnmarshaling);
void marshal_VkRenderPassCreateInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassCreateInfo2* forMarshaling);
void unmarshal_VkRenderPassCreateInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassCreateInfo2* forUnmarshaling);
void marshal_VkSubpassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassBeginInfo* forMarshaling);
void unmarshal_VkSubpassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassBeginInfo* forUnmarshaling);
void marshal_VkSubpassEndInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassEndInfo* forMarshaling);
void unmarshal_VkSubpassEndInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassEndInfo* forUnmarshaling);
#define OP_vkCreateRenderPass2 279590827
@@ -1749,267 +2129,333 @@
#define OP_vkCmdEndRenderPass2 221297834
void marshal_VkPhysicalDevice8BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice8BitStorageFeatures* forMarshaling);
void unmarshal_VkPhysicalDevice8BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevice8BitStorageFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceDriverProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDriverProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceDriverProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDriverProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderAtomicInt64Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderAtomicInt64Features* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderFloat16Int8Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderFloat16Int8Features* forUnmarshaling);
void marshal_VkPhysicalDeviceFloatControlsProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFloatControlsProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceFloatControlsProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFloatControlsProperties* forUnmarshaling);
void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling);
void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetLayoutBindingFlagsCreateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceDescriptorIndexingFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDescriptorIndexingFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceDescriptorIndexingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDescriptorIndexingProperties* forUnmarshaling);
void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling);
void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetVariableDescriptorCountAllocateInfo* forUnmarshaling);
void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling);
void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorSetVariableDescriptorCountLayoutSupport* forUnmarshaling);
void marshal_VkSubpassDescriptionDepthStencilResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDescriptionDepthStencilResolve* forMarshaling);
void unmarshal_VkSubpassDescriptionDepthStencilResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassDescriptionDepthStencilResolve* forUnmarshaling);
void marshal_VkPhysicalDeviceDepthStencilResolveProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDepthStencilResolveProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceScalarBlockLayoutFeatures* forUnmarshaling);
void marshal_VkImageStencilUsageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageStencilUsageCreateInfo* forMarshaling);
void unmarshal_VkImageStencilUsageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageStencilUsageCreateInfo* forUnmarshaling);
void marshal_VkSamplerReductionModeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerReductionModeCreateInfo* forMarshaling);
void unmarshal_VkSamplerReductionModeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerReductionModeCreateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSamplerFilterMinmaxProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVulkanMemoryModelFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceImagelessFramebufferFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImagelessFramebufferFeatures* forUnmarshaling);
void marshal_VkFramebufferAttachmentImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferAttachmentImageInfo* forMarshaling);
void unmarshal_VkFramebufferAttachmentImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFramebufferAttachmentImageInfo* forUnmarshaling);
void marshal_VkFramebufferAttachmentsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferAttachmentsCreateInfo* forMarshaling);
void unmarshal_VkFramebufferAttachmentsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFramebufferAttachmentsCreateInfo* forUnmarshaling);
void marshal_VkRenderPassAttachmentBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassAttachmentBeginInfo* forMarshaling);
void unmarshal_VkRenderPassAttachmentBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassAttachmentBeginInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forUnmarshaling);
void marshal_VkAttachmentReferenceStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentReferenceStencilLayout* forMarshaling);
void unmarshal_VkAttachmentReferenceStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentReferenceStencilLayout* forUnmarshaling);
void marshal_VkAttachmentDescriptionStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentDescriptionStencilLayout* forMarshaling);
void unmarshal_VkAttachmentDescriptionStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentDescriptionStencilLayout* forUnmarshaling);
void marshal_VkPhysicalDeviceHostQueryResetFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceHostQueryResetFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceHostQueryResetFeatures* forUnmarshaling);
#define OP_vkResetQueryPool 252097672
void marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTimelineSemaphoreFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceTimelineSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTimelineSemaphoreProperties* forUnmarshaling);
void marshal_VkSemaphoreTypeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreTypeCreateInfo* forMarshaling);
void unmarshal_VkSemaphoreTypeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreTypeCreateInfo* forUnmarshaling);
void marshal_VkTimelineSemaphoreSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTimelineSemaphoreSubmitInfo* forMarshaling);
void unmarshal_VkTimelineSemaphoreSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkTimelineSemaphoreSubmitInfo* forUnmarshaling);
void marshal_VkSemaphoreWaitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreWaitInfo* forMarshaling);
void unmarshal_VkSemaphoreWaitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreWaitInfo* forUnmarshaling);
void marshal_VkSemaphoreSignalInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreSignalInfo* forMarshaling);
void unmarshal_VkSemaphoreSignalInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreSignalInfo* forUnmarshaling);
#define OP_vkGetSemaphoreCounterValue 267066974
@@ -2017,42 +2463,52 @@
#define OP_vkSignalSemaphore 271024127
void marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceBufferDeviceAddressFeatures* forUnmarshaling);
void marshal_VkBufferDeviceAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferDeviceAddressInfo* forMarshaling);
void unmarshal_VkBufferDeviceAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferDeviceAddressInfo* forUnmarshaling);
void marshal_VkBufferOpaqueCaptureAddressCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling);
void unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferOpaqueCaptureAddressCreateInfo* forUnmarshaling);
void marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling);
void unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryOpaqueCaptureAddressAllocateInfo* forUnmarshaling);
void marshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling);
void unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceMemoryOpaqueCaptureAddressInfo* forUnmarshaling);
#define OP_vkGetBufferDeviceAddress 222632266
@@ -2062,18 +2518,22 @@
#ifdef VK_KHR_surface
void marshal_VkSurfaceCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesKHR* forMarshaling);
void unmarshal_VkSurfaceCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceCapabilitiesKHR* forUnmarshaling);
void marshal_VkSurfaceFormatKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFormatKHR* forMarshaling);
void unmarshal_VkSurfaceFormatKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceFormatKHR* forUnmarshaling);
#define OP_vkDestroySurfaceKHR 20165
@@ -2085,18 +2545,22 @@
#ifdef VK_KHR_swapchain
void marshal_VkSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainCreateInfoKHR* forMarshaling);
void unmarshal_VkSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSwapchainCreateInfoKHR* forUnmarshaling);
void marshal_VkPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentInfoKHR* forMarshaling);
void unmarshal_VkPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPresentInfoKHR* forUnmarshaling);
#define OP_vkCreateSwapchainKHR 20170
@@ -2106,50 +2570,62 @@
#define OP_vkQueuePresentKHR 20174
void marshal_VkImageSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSwapchainCreateInfoKHR* forMarshaling);
void unmarshal_VkImageSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageSwapchainCreateInfoKHR* forUnmarshaling);
void marshal_VkBindImageMemorySwapchainInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemorySwapchainInfoKHR* forMarshaling);
void unmarshal_VkBindImageMemorySwapchainInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindImageMemorySwapchainInfoKHR* forUnmarshaling);
void marshal_VkAcquireNextImageInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAcquireNextImageInfoKHR* forMarshaling);
void unmarshal_VkAcquireNextImageInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAcquireNextImageInfoKHR* forUnmarshaling);
void marshal_VkDeviceGroupPresentCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling);
void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling);
void marshal_VkDeviceGroupPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupPresentInfoKHR* forMarshaling);
void unmarshal_VkDeviceGroupPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupPresentInfoKHR* forUnmarshaling);
void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling);
void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling);
#define OP_vkGetDeviceGroupPresentCapabilitiesKHR 20175
@@ -2160,58 +2636,72 @@
#ifdef VK_KHR_display
void marshal_VkDisplayModeParametersKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayModeParametersKHR* forMarshaling);
void unmarshal_VkDisplayModeParametersKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayModeParametersKHR* forUnmarshaling);
void marshal_VkDisplayModeCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayModeCreateInfoKHR* forMarshaling);
void unmarshal_VkDisplayModeCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayModeCreateInfoKHR* forUnmarshaling);
void marshal_VkDisplayModePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayModePropertiesKHR* forMarshaling);
void unmarshal_VkDisplayModePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayModePropertiesKHR* forUnmarshaling);
void marshal_VkDisplayPlaneCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilitiesKHR* forMarshaling);
void unmarshal_VkDisplayPlaneCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlaneCapabilitiesKHR* forUnmarshaling);
void marshal_VkDisplayPlanePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlanePropertiesKHR* forMarshaling);
void unmarshal_VkDisplayPlanePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlanePropertiesKHR* forUnmarshaling);
void marshal_VkDisplayPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPropertiesKHR* forMarshaling);
void unmarshal_VkDisplayPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPropertiesKHR* forUnmarshaling);
void marshal_VkDisplaySurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplaySurfaceCreateInfoKHR* forMarshaling);
void unmarshal_VkDisplaySurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplaySurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceDisplayPropertiesKHR 20179
@@ -2225,10 +2715,12 @@
#ifdef VK_KHR_display_swapchain
void marshal_VkDisplayPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPresentInfoKHR* forMarshaling);
void unmarshal_VkDisplayPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPresentInfoKHR* forUnmarshaling);
#define OP_vkCreateSharedSwapchainsKHR 20186
@@ -2236,10 +2728,12 @@
#ifdef VK_KHR_xlib_surface
void marshal_VkXlibSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXlibSurfaceCreateInfoKHR* forMarshaling);
void unmarshal_VkXlibSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkXlibSurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateXlibSurfaceKHR 20187
@@ -2248,10 +2742,12 @@
#ifdef VK_KHR_xcb_surface
void marshal_VkXcbSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXcbSurfaceCreateInfoKHR* forMarshaling);
void unmarshal_VkXcbSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkXcbSurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateXcbSurfaceKHR 20189
@@ -2260,10 +2756,12 @@
#ifdef VK_KHR_wayland_surface
void marshal_VkWaylandSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWaylandSurfaceCreateInfoKHR* forMarshaling);
void unmarshal_VkWaylandSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWaylandSurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateWaylandSurfaceKHR 20191
@@ -2272,10 +2770,12 @@
#ifdef VK_KHR_android_surface
void marshal_VkAndroidSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidSurfaceCreateInfoKHR* forMarshaling);
void unmarshal_VkAndroidSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAndroidSurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateAndroidSurfaceKHR 20195
@@ -2283,10 +2783,12 @@
#ifdef VK_KHR_win32_surface
void marshal_VkWin32SurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32SurfaceCreateInfoKHR* forMarshaling);
void unmarshal_VkWin32SurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWin32SurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateWin32SurfaceKHR 20196
@@ -2446,34 +2948,42 @@
#ifdef VK_KHR_external_memory_win32
void marshal_VkImportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkImportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportMemoryWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkExportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkExportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportMemoryWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkMemoryWin32HandlePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryWin32HandlePropertiesKHR* forMarshaling);
void unmarshal_VkMemoryWin32HandlePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryWin32HandlePropertiesKHR* forUnmarshaling);
void marshal_VkMemoryGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkMemoryGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryGetWin32HandleInfoKHR* forUnmarshaling);
#define OP_vkGetMemoryWin32HandleKHR 20211
@@ -2482,26 +2992,32 @@
#ifdef VK_KHR_external_memory_fd
void marshal_VkImportMemoryFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryFdInfoKHR* forMarshaling);
void unmarshal_VkImportMemoryFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportMemoryFdInfoKHR* forUnmarshaling);
void marshal_VkMemoryFdPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryFdPropertiesKHR* forMarshaling);
void unmarshal_VkMemoryFdPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryFdPropertiesKHR* forUnmarshaling);
void marshal_VkMemoryGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetFdInfoKHR* forMarshaling);
void unmarshal_VkMemoryGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryGetFdInfoKHR* forUnmarshaling);
#define OP_vkGetMemoryFdKHR 20213
@@ -2510,10 +3026,12 @@
#ifdef VK_KHR_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling);
void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling);
#endif
@@ -2537,34 +3055,42 @@
#ifdef VK_KHR_external_semaphore_win32
void marshal_VkImportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkExportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkD3D12FenceSubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkD3D12FenceSubmitInfoKHR* forMarshaling);
void unmarshal_VkD3D12FenceSubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkD3D12FenceSubmitInfoKHR* forUnmarshaling);
void marshal_VkSemaphoreGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling);
#define OP_vkImportSemaphoreWin32HandleKHR 20216
@@ -2573,18 +3099,22 @@
#ifdef VK_KHR_external_semaphore_fd
void marshal_VkImportSemaphoreFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportSemaphoreFdInfoKHR* forMarshaling);
void unmarshal_VkImportSemaphoreFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportSemaphoreFdInfoKHR* forUnmarshaling);
void marshal_VkSemaphoreGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreGetFdInfoKHR* forMarshaling);
void unmarshal_VkSemaphoreGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSemaphoreGetFdInfoKHR* forUnmarshaling);
#define OP_vkImportSemaphoreFdKHR 20218
@@ -2593,10 +3123,12 @@
#ifdef VK_KHR_push_descriptor
void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling);
#define OP_vkCmdPushDescriptorSetKHR 20220
@@ -2621,26 +3153,32 @@
#ifdef VK_KHR_incremental_present
void marshal_VkRectLayerKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRectLayerKHR* forMarshaling);
void unmarshal_VkRectLayerKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRectLayerKHR* forUnmarshaling);
void marshal_VkPresentRegionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentRegionKHR* forMarshaling);
void unmarshal_VkPresentRegionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPresentRegionKHR* forUnmarshaling);
void marshal_VkPresentRegionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentRegionsKHR* forMarshaling);
void unmarshal_VkPresentRegionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPresentRegionsKHR* forUnmarshaling);
#endif
@@ -2712,10 +3250,12 @@
#ifdef VK_KHR_shared_presentable_image
void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling);
void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling);
#define OP_vkGetSwapchainStatusKHR 20229
@@ -2740,26 +3280,32 @@
#ifdef VK_KHR_external_fence_win32
void marshal_VkImportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportFenceWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkImportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportFenceWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkExportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportFenceWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkExportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportFenceWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkFenceGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFenceGetWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkFenceGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFenceGetWin32HandleInfoKHR* forUnmarshaling);
#define OP_vkImportFenceWin32HandleKHR 20231
@@ -2768,18 +3314,22 @@
#ifdef VK_KHR_external_fence_fd
void marshal_VkImportFenceFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportFenceFdInfoKHR* forMarshaling);
void unmarshal_VkImportFenceFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportFenceFdInfoKHR* forUnmarshaling);
void marshal_VkFenceGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFenceGetFdInfoKHR* forMarshaling);
void unmarshal_VkFenceGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFenceGetFdInfoKHR* forUnmarshaling);
#define OP_vkImportFenceFdKHR 20233
@@ -2788,66 +3338,82 @@
#ifdef VK_KHR_performance_query
void marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePerformanceQueryFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePerformanceQueryPropertiesKHR* forUnmarshaling);
void marshal_VkPerformanceCounterKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceCounterKHR* forMarshaling);
void unmarshal_VkPerformanceCounterKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceCounterKHR* forUnmarshaling);
void marshal_VkPerformanceCounterDescriptionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceCounterDescriptionKHR* forMarshaling);
void unmarshal_VkPerformanceCounterDescriptionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceCounterDescriptionKHR* forUnmarshaling);
void marshal_VkQueryPoolPerformanceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling);
void unmarshal_VkQueryPoolPerformanceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueryPoolPerformanceCreateInfoKHR* forUnmarshaling);
void marshal_VkPerformanceCounterResultKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceCounterResultKHR* forMarshaling);
void unmarshal_VkPerformanceCounterResultKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceCounterResultKHR* forUnmarshaling);
void marshal_VkAcquireProfilingLockInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAcquireProfilingLockInfoKHR* forMarshaling);
void unmarshal_VkAcquireProfilingLockInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAcquireProfilingLockInfoKHR* forUnmarshaling);
void marshal_VkPerformanceQuerySubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceQuerySubmitInfoKHR* forMarshaling);
void unmarshal_VkPerformanceQuerySubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceQuerySubmitInfoKHR* forUnmarshaling);
#define OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR 299033148
@@ -2880,26 +3446,32 @@
#ifdef VK_KHR_get_surface_capabilities2
void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling);
void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling);
void marshal_VkSurfaceCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilities2KHR* forMarshaling);
void unmarshal_VkSurfaceCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceCapabilities2KHR* forUnmarshaling);
void marshal_VkSurfaceFormat2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFormat2KHR* forMarshaling);
void unmarshal_VkSurfaceFormat2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceFormat2KHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR 20235
@@ -2918,42 +3490,52 @@
#ifdef VK_KHR_get_display_properties2
void marshal_VkDisplayProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayProperties2KHR* forMarshaling);
void unmarshal_VkDisplayProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayProperties2KHR* forUnmarshaling);
void marshal_VkDisplayPlaneProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneProperties2KHR* forMarshaling);
void unmarshal_VkDisplayPlaneProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlaneProperties2KHR* forUnmarshaling);
void marshal_VkDisplayModeProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayModeProperties2KHR* forMarshaling);
void unmarshal_VkDisplayModeProperties2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayModeProperties2KHR* forUnmarshaling);
void marshal_VkDisplayPlaneInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneInfo2KHR* forMarshaling);
void unmarshal_VkDisplayPlaneInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlaneInfo2KHR* forUnmarshaling);
void marshal_VkDisplayPlaneCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilities2KHR* forMarshaling);
void unmarshal_VkDisplayPlaneCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPlaneCapabilities2KHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceDisplayProperties2KHR 20237
@@ -3049,18 +3631,22 @@
#ifdef VK_KHR_portability_subset
void marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePortabilitySubsetFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePortabilitySubsetPropertiesKHR* forUnmarshaling);
#endif
@@ -3100,10 +3686,12 @@
#ifdef VK_KHR_shader_clock
void marshal_VkPhysicalDeviceShaderClockFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderClockFeaturesKHR* forUnmarshaling);
#endif
@@ -3173,52 +3761,64 @@
#ifdef VK_KHR_shader_terminate_invocation
void marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_fragment_shading_rate
void marshal_VkFragmentShadingRateAttachmentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling);
void unmarshal_VkFragmentShadingRateAttachmentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFragmentShadingRateAttachmentInfoKHR* forUnmarshaling);
void marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling);
void unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineFragmentShadingRateStateCreateInfoKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentShadingRateKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateKHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceFragmentShadingRatesKHR 272978593
@@ -3229,10 +3829,12 @@
#ifdef VK_KHR_surface_protected_capabilities
void marshal_VkSurfaceProtectedCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceProtectedCapabilitiesKHR* forMarshaling);
void unmarshal_VkSurfaceProtectedCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceProtectedCapabilitiesKHR* forUnmarshaling);
#endif
@@ -3291,58 +3893,72 @@
#ifdef VK_KHR_pipeline_executable_properties
void marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forUnmarshaling);
void marshal_VkPipelineInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineInfoKHR* forMarshaling);
void unmarshal_VkPipelineInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineInfoKHR* forUnmarshaling);
void marshal_VkPipelineExecutablePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutablePropertiesKHR* forMarshaling);
void unmarshal_VkPipelineExecutablePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutablePropertiesKHR* forUnmarshaling);
void marshal_VkPipelineExecutableInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableInfoKHR* forMarshaling);
void unmarshal_VkPipelineExecutableInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutableInfoKHR* forUnmarshaling);
void marshal_VkPipelineExecutableStatisticValueKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticValueKHR* forMarshaling);
void unmarshal_VkPipelineExecutableStatisticValueKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutableStatisticValueKHR* forUnmarshaling);
void marshal_VkPipelineExecutableStatisticKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticKHR* forMarshaling);
void unmarshal_VkPipelineExecutableStatisticKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutableStatisticKHR* forUnmarshaling);
void marshal_VkPipelineExecutableInternalRepresentationKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* forMarshaling);
void unmarshal_VkPipelineExecutableInternalRepresentationKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineExecutableInternalRepresentationKHR* forUnmarshaling);
#define OP_vkGetPipelineExecutablePropertiesKHR 269458798
@@ -3352,10 +3968,12 @@
#ifdef VK_KHR_pipeline_library
void marshal_VkPipelineLibraryCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineLibraryCreateInfoKHR* forMarshaling);
void unmarshal_VkPipelineLibraryCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineLibraryCreateInfoKHR* forUnmarshaling);
#endif
@@ -3364,90 +3982,112 @@
#ifdef VK_KHR_copy_commands2
void marshal_VkBufferCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferCopy2KHR* forMarshaling);
void unmarshal_VkBufferCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferCopy2KHR* forUnmarshaling);
void marshal_VkCopyBufferInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyBufferInfo2KHR* forMarshaling);
void unmarshal_VkCopyBufferInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyBufferInfo2KHR* forUnmarshaling);
void marshal_VkImageCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageCopy2KHR* forMarshaling);
void unmarshal_VkImageCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageCopy2KHR* forUnmarshaling);
void marshal_VkCopyImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyImageInfo2KHR* forMarshaling);
void unmarshal_VkCopyImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyImageInfo2KHR* forUnmarshaling);
void marshal_VkBufferImageCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferImageCopy2KHR* forMarshaling);
void unmarshal_VkBufferImageCopy2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferImageCopy2KHR* forUnmarshaling);
void marshal_VkCopyBufferToImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyBufferToImageInfo2KHR* forMarshaling);
void unmarshal_VkCopyBufferToImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyBufferToImageInfo2KHR* forUnmarshaling);
void marshal_VkCopyImageToBufferInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyImageToBufferInfo2KHR* forMarshaling);
void unmarshal_VkCopyImageToBufferInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyImageToBufferInfo2KHR* forUnmarshaling);
void marshal_VkImageBlit2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageBlit2KHR* forMarshaling);
void unmarshal_VkImageBlit2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageBlit2KHR* forUnmarshaling);
void marshal_VkBlitImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBlitImageInfo2KHR* forMarshaling);
void unmarshal_VkBlitImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBlitImageInfo2KHR* forUnmarshaling);
void marshal_VkImageResolve2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageResolve2KHR* forMarshaling);
void unmarshal_VkImageResolve2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageResolve2KHR* forUnmarshaling);
void marshal_VkResolveImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkResolveImageInfo2KHR* forMarshaling);
void unmarshal_VkResolveImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkResolveImageInfo2KHR* forUnmarshaling);
#define OP_vkCmdCopyBuffer2KHR 247893766
@@ -3460,10 +4100,12 @@
#ifdef VK_ANDROID_native_buffer
void marshal_VkNativeBufferANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkNativeBufferANDROID* forMarshaling);
void unmarshal_VkNativeBufferANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkNativeBufferANDROID* forUnmarshaling);
#define OP_vkGetSwapchainGrallocUsageANDROID 20251
@@ -3473,10 +4115,12 @@
#ifdef VK_EXT_debug_report
void marshal_VkDebugReportCallbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugReportCallbackCreateInfoEXT* forMarshaling);
void unmarshal_VkDebugReportCallbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugReportCallbackCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateDebugReportCallbackEXT 20254
@@ -3492,10 +4136,12 @@
#ifdef VK_AMD_rasterization_order
void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling);
void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling);
#endif
@@ -3506,26 +4152,32 @@
#ifdef VK_EXT_debug_marker
void marshal_VkDebugMarkerObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerObjectNameInfoEXT* forMarshaling);
void unmarshal_VkDebugMarkerObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugMarkerObjectNameInfoEXT* forUnmarshaling);
void marshal_VkDebugMarkerObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerObjectTagInfoEXT* forMarshaling);
void unmarshal_VkDebugMarkerObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugMarkerObjectTagInfoEXT* forUnmarshaling);
void marshal_VkDebugMarkerMarkerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerMarkerInfoEXT* forMarshaling);
void unmarshal_VkDebugMarkerMarkerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugMarkerMarkerInfoEXT* forUnmarshaling);
#define OP_vkDebugMarkerSetObjectTagEXT 20257
@@ -3539,52 +4191,64 @@
#ifdef VK_NV_dedicated_allocation
void marshal_VkDedicatedAllocationImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationImageCreateInfoNV* forMarshaling);
void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling);
void marshal_VkDedicatedAllocationBufferCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling);
void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling);
void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling);
void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_transform_feedback
void marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTransformFeedbackFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTransformFeedbackPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationStateStreamCreateInfoEXT* forUnmarshaling);
#define OP_vkCmdBindTransformFeedbackBuffersEXT 267779978
@@ -3597,18 +4261,22 @@
#ifdef VK_NVX_image_view_handle
void marshal_VkImageViewHandleInfoNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewHandleInfoNVX* forMarshaling);
void unmarshal_VkImageViewHandleInfoNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageViewHandleInfoNVX* forUnmarshaling);
void marshal_VkImageViewAddressPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewAddressPropertiesNVX* forMarshaling);
void unmarshal_VkImageViewAddressPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageViewAddressPropertiesNVX* forUnmarshaling);
#define OP_vkGetImageViewHandleNVX 204379647
@@ -3627,28 +4295,34 @@
#ifdef VK_AMD_texture_gather_bias_lod
void marshal_VkTextureLODGatherFormatPropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* forMarshaling);
void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling);
#endif
#ifdef VK_AMD_shader_info
void marshal_VkShaderResourceUsageAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkShaderResourceUsageAMD* forMarshaling);
void unmarshal_VkShaderResourceUsageAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkShaderResourceUsageAMD* forUnmarshaling);
void marshal_VkShaderStatisticsInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkShaderStatisticsInfoAMD* forMarshaling);
void unmarshal_VkShaderStatisticsInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkShaderStatisticsInfoAMD* forUnmarshaling);
#define OP_vkGetShaderInfoAMD 20264
@@ -3658,10 +4332,12 @@
#ifdef VK_GGP_stream_descriptor_surface
void marshal_VkStreamDescriptorSurfaceCreateInfoGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling);
void unmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkStreamDescriptorSurfaceCreateInfoGGP* forUnmarshaling);
#define OP_vkCreateStreamDescriptorSurfaceGGP 241902685
@@ -3669,10 +4345,12 @@
#ifdef VK_NV_corner_sampled_image
void marshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCornerSampledImageFeaturesNV* forUnmarshaling);
#endif
@@ -3681,10 +4359,12 @@
#ifdef VK_NV_external_memory_capabilities
void marshal_VkExternalImageFormatPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalImageFormatPropertiesNV* forMarshaling);
void unmarshal_VkExternalImageFormatPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalImageFormatPropertiesNV* forUnmarshaling);
#define OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV 20265
@@ -3692,36 +4372,44 @@
#ifdef VK_NV_external_memory
void marshal_VkExternalMemoryImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfoNV* forMarshaling);
void unmarshal_VkExternalMemoryImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalMemoryImageCreateInfoNV* forUnmarshaling);
void marshal_VkExportMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfoNV* forMarshaling);
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 unmarshal_VkImportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportMemoryWin32HandleInfoNV* forUnmarshaling);
void marshal_VkExportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoNV* forMarshaling);
void unmarshal_VkExportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExportMemoryWin32HandleInfoNV* forUnmarshaling);
#define OP_vkGetMemoryWin32HandleNV 20266
@@ -3729,30 +4417,36 @@
#ifdef VK_NV_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling);
void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_validation_flags
void marshal_VkValidationFlagsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationFlagsEXT* forMarshaling);
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 unmarshal_VkViSurfaceCreateInfoNN(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkViSurfaceCreateInfoNN* forUnmarshaling);
#define OP_vkCreateViSurfaceNN 20267
@@ -3764,54 +4458,66 @@
#ifdef VK_EXT_texture_compression_astc_hdr
void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_astc_decode_mode
void marshal_VkImageViewASTCDecodeModeEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewASTCDecodeModeEXT* forMarshaling);
void unmarshal_VkImageViewASTCDecodeModeEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageViewASTCDecodeModeEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_conditional_rendering
void marshal_VkConditionalRenderingBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkConditionalRenderingBeginInfoEXT* forMarshaling);
void unmarshal_VkConditionalRenderingBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkConditionalRenderingBeginInfoEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling);
void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling);
void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling);
#define OP_vkCmdBeginConditionalRenderingEXT 20268
@@ -3820,18 +4526,22 @@
#ifdef VK_NV_clip_space_w_scaling
void marshal_VkViewportWScalingNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkViewportWScalingNV* forMarshaling);
void unmarshal_VkViewportWScalingNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkViewportWScalingNV* forUnmarshaling);
void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling);
#define OP_vkCmdSetViewportWScalingNV 20279
@@ -3846,10 +4556,12 @@
#ifdef VK_EXT_display_surface_counter
void marshal_VkSurfaceCapabilities2EXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilities2EXT* forMarshaling);
void unmarshal_VkSurfaceCapabilities2EXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceCapabilities2EXT* forUnmarshaling);
#define OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT 20283
@@ -3857,34 +4569,42 @@
#ifdef VK_EXT_display_control
void marshal_VkDisplayPowerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPowerInfoEXT* forMarshaling);
void unmarshal_VkDisplayPowerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayPowerInfoEXT* forUnmarshaling);
void marshal_VkDeviceEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceEventInfoEXT* forMarshaling);
void unmarshal_VkDeviceEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceEventInfoEXT* forUnmarshaling);
void marshal_VkDisplayEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayEventInfoEXT* forMarshaling);
void unmarshal_VkDisplayEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayEventInfoEXT* forUnmarshaling);
void marshal_VkSwapchainCounterCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainCounterCreateInfoEXT* forMarshaling);
void unmarshal_VkSwapchainCounterCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSwapchainCounterCreateInfoEXT* forUnmarshaling);
#define OP_vkDisplayPowerControlEXT 20284
@@ -3895,34 +4615,42 @@
#ifdef VK_GOOGLE_display_timing
void marshal_VkRefreshCycleDurationGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRefreshCycleDurationGOOGLE* forMarshaling);
void unmarshal_VkRefreshCycleDurationGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRefreshCycleDurationGOOGLE* forUnmarshaling);
void marshal_VkPastPresentationTimingGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPastPresentationTimingGOOGLE* forMarshaling);
void unmarshal_VkPastPresentationTimingGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPastPresentationTimingGOOGLE* forUnmarshaling);
void marshal_VkPresentTimeGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentTimeGOOGLE* forMarshaling);
void unmarshal_VkPresentTimeGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPresentTimeGOOGLE* forUnmarshaling);
void marshal_VkPresentTimesInfoGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentTimesInfoGOOGLE* forMarshaling);
void unmarshal_VkPresentTimesInfoGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPresentTimesInfoGOOGLE* forUnmarshaling);
#define OP_vkGetRefreshCycleDurationGOOGLE 20288
@@ -3937,46 +4665,56 @@
#ifdef VK_NVX_multiview_per_view_attributes
void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling);
void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling);
#endif
#ifdef VK_NV_viewport_swizzle
void marshal_VkViewportSwizzleNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkViewportSwizzleNV* forMarshaling);
void unmarshal_VkViewportSwizzleNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkViewportSwizzleNV* forUnmarshaling);
void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_discard_rectangles
void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling);
void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling);
#define OP_vkCmdSetDiscardRectangleEXT 20290
@@ -3984,36 +4722,44 @@
#ifdef VK_EXT_conservative_rasterization
void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_depth_clip_enable
void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling);
#endif
@@ -4022,18 +4768,22 @@
#ifdef VK_EXT_hdr_metadata
void marshal_VkXYColorEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXYColorEXT* forMarshaling);
void unmarshal_VkXYColorEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkXYColorEXT* forUnmarshaling);
void marshal_VkHdrMetadataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkHdrMetadataEXT* forMarshaling);
void unmarshal_VkHdrMetadataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkHdrMetadataEXT* forUnmarshaling);
#define OP_vkSetHdrMetadataEXT 20291
@@ -4041,10 +4791,12 @@
#ifdef VK_MVK_ios_surface
void marshal_VkIOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIOSSurfaceCreateInfoMVK* forMarshaling);
void unmarshal_VkIOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkIOSSurfaceCreateInfoMVK* forUnmarshaling);
#define OP_vkCreateIOSSurfaceMVK 20292
@@ -4052,10 +4804,12 @@
#ifdef VK_MVK_macos_surface
void marshal_VkMacOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMacOSSurfaceCreateInfoMVK* forMarshaling);
void unmarshal_VkMacOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMacOSSurfaceCreateInfoMVK* forUnmarshaling);
#define OP_vkCreateMacOSSurfaceMVK 20293
@@ -4075,42 +4829,52 @@
#ifdef VK_EXT_debug_utils
void marshal_VkDebugUtilsLabelEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsLabelEXT* forMarshaling);
void unmarshal_VkDebugUtilsLabelEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsLabelEXT* forUnmarshaling);
void marshal_VkDebugUtilsObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsObjectNameInfoEXT* forMarshaling);
void unmarshal_VkDebugUtilsObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsObjectNameInfoEXT* forUnmarshaling);
void marshal_VkDebugUtilsMessengerCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling);
void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling);
void marshal_VkDebugUtilsMessengerCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling);
void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling);
void marshal_VkDebugUtilsObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsObjectTagInfoEXT* forMarshaling);
void unmarshal_VkDebugUtilsObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDebugUtilsObjectTagInfoEXT* forUnmarshaling);
#define OP_vkSetDebugUtilsObjectNameEXT 20294
@@ -4128,50 +4892,62 @@
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void marshal_VkAndroidHardwareBufferUsageANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferUsageANDROID* forMarshaling);
void unmarshal_VkAndroidHardwareBufferUsageANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAndroidHardwareBufferUsageANDROID* forUnmarshaling);
void marshal_VkAndroidHardwareBufferPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling);
void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling);
void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling);
void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling);
void marshal_VkImportAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling);
void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling);
void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling);
void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling);
void marshal_VkExternalFormatANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalFormatANDROID* forMarshaling);
void unmarshal_VkExternalFormatANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkExternalFormatANDROID* forUnmarshaling);
#define OP_vkGetAndroidHardwareBufferPropertiesANDROID 20305
@@ -4196,34 +4972,42 @@
#ifdef VK_EXT_inline_uniform_block
void marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling);
void marshal_VkWriteDescriptorSetInlineUniformBlockEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling);
void unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling);
void marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling);
void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling);
#endif
@@ -4232,66 +5016,82 @@
#ifdef VK_EXT_sample_locations
void marshal_VkSampleLocationEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSampleLocationEXT* forMarshaling);
void unmarshal_VkSampleLocationEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSampleLocationEXT* forUnmarshaling);
void marshal_VkSampleLocationsInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSampleLocationsInfoEXT* forMarshaling);
void unmarshal_VkSampleLocationsInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSampleLocationsInfoEXT* forUnmarshaling);
void marshal_VkAttachmentSampleLocationsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentSampleLocationsEXT* forMarshaling);
void unmarshal_VkAttachmentSampleLocationsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAttachmentSampleLocationsEXT* forUnmarshaling);
void marshal_VkSubpassSampleLocationsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassSampleLocationsEXT* forMarshaling);
void unmarshal_VkSubpassSampleLocationsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSubpassSampleLocationsEXT* forUnmarshaling);
void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling);
void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling);
void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling);
void marshal_VkMultisamplePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMultisamplePropertiesEXT* forMarshaling);
void unmarshal_VkMultisamplePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMultisamplePropertiesEXT* forUnmarshaling);
#define OP_vkCmdSetSampleLocationsEXT 20307
@@ -4300,46 +5100,56 @@
#ifdef VK_EXT_blend_operation_advanced
void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_NV_fragment_coverage_to_color
void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling);
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling);
#endif
@@ -4348,18 +5158,22 @@
#ifdef VK_NV_shader_sm_builtins
void marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forUnmarshaling);
#endif
@@ -4368,50 +5182,62 @@
#ifdef VK_EXT_image_drm_format_modifier
void marshal_VkDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesEXT* forMarshaling);
void unmarshal_VkDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDrmFormatModifierPropertiesEXT* forUnmarshaling);
void marshal_VkDrmFormatModifierPropertiesListEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesListEXT* forMarshaling);
void unmarshal_VkDrmFormatModifierPropertiesListEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDrmFormatModifierPropertiesListEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forUnmarshaling);
void marshal_VkImageDrmFormatModifierListCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling);
void unmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageDrmFormatModifierListCreateInfoEXT* forUnmarshaling);
void marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling);
void unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageDrmFormatModifierExplicitCreateInfoEXT* forUnmarshaling);
void marshal_VkImageDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierPropertiesEXT* forMarshaling);
void unmarshal_VkImageDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImageDrmFormatModifierPropertiesEXT* forUnmarshaling);
#define OP_vkGetImageDrmFormatModifierPropertiesEXT 251301237
@@ -4419,18 +5245,22 @@
#ifdef VK_EXT_validation_cache
void marshal_VkValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationCacheCreateInfoEXT* forMarshaling);
void unmarshal_VkValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkValidationCacheCreateInfoEXT* forUnmarshaling);
void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling);
void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateValidationCacheEXT 20309
@@ -4465,58 +5295,72 @@
#ifdef VK_NV_shading_rate_image
void marshal_VkShadingRatePaletteNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkShadingRatePaletteNV* forMarshaling);
void unmarshal_VkShadingRatePaletteNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkShadingRatePaletteNV* forUnmarshaling);
void marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportShadingRateImageStateCreateInfoNV* forUnmarshaling);
void marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShadingRateImageFeaturesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShadingRateImagePropertiesNV* forUnmarshaling);
void marshal_VkCoarseSampleLocationNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCoarseSampleLocationNV* forMarshaling);
void unmarshal_VkCoarseSampleLocationNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCoarseSampleLocationNV* forUnmarshaling);
void marshal_VkCoarseSampleOrderCustomNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCoarseSampleOrderCustomNV* forMarshaling);
void unmarshal_VkCoarseSampleOrderCustomNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCoarseSampleOrderCustomNV* forUnmarshaling);
void marshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forUnmarshaling);
#define OP_vkCmdBindShadingRateImageNV 238618340
@@ -4526,106 +5370,132 @@
#ifdef VK_NV_ray_tracing
void marshal_VkRayTracingShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoNV* forMarshaling);
void unmarshal_VkRayTracingShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingShaderGroupCreateInfoNV* forUnmarshaling);
void marshal_VkRayTracingPipelineCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoNV* forMarshaling);
void unmarshal_VkRayTracingPipelineCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingPipelineCreateInfoNV* forUnmarshaling);
void marshal_VkGeometryTrianglesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryTrianglesNV* forMarshaling);
void unmarshal_VkGeometryTrianglesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeometryTrianglesNV* forUnmarshaling);
void marshal_VkGeometryAABBNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryAABBNV* forMarshaling);
void unmarshal_VkGeometryAABBNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeometryAABBNV* forUnmarshaling);
void marshal_VkGeometryDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryDataNV* forMarshaling);
void unmarshal_VkGeometryDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeometryDataNV* forUnmarshaling);
void marshal_VkGeometryNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryNV* forMarshaling);
void unmarshal_VkGeometryNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeometryNV* forUnmarshaling);
void marshal_VkAccelerationStructureInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureInfoNV* forMarshaling);
void unmarshal_VkAccelerationStructureInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureInfoNV* forUnmarshaling);
void marshal_VkAccelerationStructureCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoNV* forMarshaling);
void unmarshal_VkAccelerationStructureCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureCreateInfoNV* forUnmarshaling);
void marshal_VkBindAccelerationStructureMemoryInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindAccelerationStructureMemoryInfoNV* forMarshaling);
void unmarshal_VkBindAccelerationStructureMemoryInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindAccelerationStructureMemoryInfoNV* forUnmarshaling);
void marshal_VkWriteDescriptorSetAccelerationStructureNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling);
void unmarshal_VkWriteDescriptorSetAccelerationStructureNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWriteDescriptorSetAccelerationStructureNV* forUnmarshaling);
void marshal_VkAccelerationStructureMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling);
void unmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureMemoryRequirementsInfoNV* forUnmarshaling);
void marshal_VkPhysicalDeviceRayTracingPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRayTracingPropertiesNV* forUnmarshaling);
void marshal_VkTransformMatrixKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTransformMatrixKHR* forMarshaling);
void unmarshal_VkTransformMatrixKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkTransformMatrixKHR* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkTransformMatrixKHR, marshal_VkTransformMatrixNV);
@@ -4634,10 +5504,12 @@
void marshal_VkAabbPositionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAabbPositionsKHR* forMarshaling);
void unmarshal_VkAabbPositionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAabbPositionsKHR* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkAabbPositionsKHR, marshal_VkAabbPositionsNV);
@@ -4646,10 +5518,12 @@
void marshal_VkAccelerationStructureInstanceKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureInstanceKHR* forMarshaling);
void unmarshal_VkAccelerationStructureInstanceKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureInstanceKHR* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkAccelerationStructureInstanceKHR, marshal_VkAccelerationStructureInstanceNV);
@@ -4673,36 +5547,44 @@
#ifdef VK_NV_representative_fragment_test
void marshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forUnmarshaling);
void marshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_filter_cubic
void marshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImageViewImageFormatInfoEXT* forUnmarshaling);
void marshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling);
void unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFilterCubicImageViewImageFormatPropertiesEXT* forUnmarshaling);
#endif
@@ -4711,36 +5593,44 @@
#ifdef VK_EXT_global_priority
void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling);
void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_external_memory_host
void marshal_VkImportMemoryHostPointerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryHostPointerInfoEXT* forMarshaling);
void unmarshal_VkImportMemoryHostPointerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImportMemoryHostPointerInfoEXT* forUnmarshaling);
void marshal_VkMemoryHostPointerPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryHostPointerPropertiesEXT* forMarshaling);
void unmarshal_VkMemoryHostPointerPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryHostPointerPropertiesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling);
#define OP_vkGetMemoryHostPointerPropertiesEXT 20313
@@ -4751,20 +5641,24 @@
#ifdef VK_AMD_pipeline_compiler_control
void marshal_VkPipelineCompilerControlCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* forMarshaling);
void unmarshal_VkPipelineCompilerControlCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCompilerControlCreateInfoAMD* forUnmarshaling);
#endif
#ifdef VK_EXT_calibrated_timestamps
void marshal_VkCalibratedTimestampInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCalibratedTimestampInfoEXT* forMarshaling);
void unmarshal_VkCalibratedTimestampInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCalibratedTimestampInfoEXT* forUnmarshaling);
#define OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT 295643221
@@ -4773,82 +5667,100 @@
#ifdef VK_AMD_shader_core_properties
void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling);
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling);
void unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceMemoryOverallocationCreateInfoAMD* forUnmarshaling);
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling);
void marshal_VkVertexInputBindingDivisorDescriptionEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling);
void unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling);
void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_GGP_frame_token
void marshal_VkPresentFrameTokenGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentFrameTokenGGP* forMarshaling);
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 unmarshal_VkPipelineCreationFeedbackEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCreationFeedbackEXT* forUnmarshaling);
void marshal_VkPipelineCreationFeedbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling);
#endif
@@ -4857,36 +5769,44 @@
#ifdef VK_NV_compute_shader_derivatives
void marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_NV_mesh_shader
void marshal_VkPhysicalDeviceMeshShaderFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMeshShaderFeaturesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceMeshShaderPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMeshShaderPropertiesNV* forUnmarshaling);
void marshal_VkDrawMeshTasksIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrawMeshTasksIndirectCommandNV* forMarshaling);
void unmarshal_VkDrawMeshTasksIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDrawMeshTasksIndirectCommandNV* forUnmarshaling);
#define OP_vkCmdDrawMeshTasksNV 207334931
@@ -4896,38 +5816,46 @@
#ifdef VK_NV_fragment_shader_barycentric
void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_NV_shader_image_footprint
void marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderImageFootprintFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_NV_scissor_exclusive
void marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineViewportExclusiveScissorStateCreateInfoNV* forUnmarshaling);
void marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExclusiveScissorFeaturesNV* forUnmarshaling);
#define OP_vkCmdSetExclusiveScissorNV 225408194
@@ -4935,18 +5863,22 @@
#ifdef VK_NV_device_diagnostic_checkpoints
void marshal_VkQueueFamilyCheckpointPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueueFamilyCheckpointPropertiesNV* forMarshaling);
void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling);
void marshal_VkCheckpointDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCheckpointDataNV* forMarshaling);
void unmarshal_VkCheckpointDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCheckpointDataNV* forUnmarshaling);
#define OP_vkCmdSetCheckpointNV 20315
@@ -4955,44 +5887,54 @@
#ifdef VK_INTEL_shader_integer_functions2
void marshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forUnmarshaling);
#endif
#ifdef VK_INTEL_performance_query
void marshal_VkPerformanceValueDataINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceValueDataINTEL* forMarshaling);
void unmarshal_VkPerformanceValueDataINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceValueDataINTEL* forUnmarshaling);
void marshal_VkPerformanceValueINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceValueINTEL* forMarshaling);
void unmarshal_VkPerformanceValueINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceValueINTEL* forUnmarshaling);
void marshal_VkInitializePerformanceApiInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkInitializePerformanceApiInfoINTEL* forMarshaling);
void unmarshal_VkInitializePerformanceApiInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkInitializePerformanceApiInfoINTEL* forUnmarshaling);
void marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling);
void unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkQueryPoolPerformanceQueryCreateInfoINTEL* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL, marshal_VkQueryPoolCreateInfoINTEL);
@@ -5001,34 +5943,42 @@
void marshal_VkPerformanceMarkerInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceMarkerInfoINTEL* forMarshaling);
void unmarshal_VkPerformanceMarkerInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceMarkerInfoINTEL* forUnmarshaling);
void marshal_VkPerformanceStreamMarkerInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceStreamMarkerInfoINTEL* forMarshaling);
void unmarshal_VkPerformanceStreamMarkerInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceStreamMarkerInfoINTEL* forUnmarshaling);
void marshal_VkPerformanceOverrideInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceOverrideInfoINTEL* forMarshaling);
void unmarshal_VkPerformanceOverrideInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceOverrideInfoINTEL* forUnmarshaling);
void marshal_VkPerformanceConfigurationAcquireInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling);
void unmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPerformanceConfigurationAcquireInfoINTEL* forUnmarshaling);
#define OP_vkInitializePerformanceApiINTEL 203336121
@@ -5044,28 +5994,34 @@
#ifdef VK_EXT_pci_bus_info
void marshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePCIBusInfoPropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_AMD_display_native_hdr
void marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling);
void unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDisplayNativeHdrSurfaceCapabilitiesAMD* forUnmarshaling);
void marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling);
void unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSwapchainDisplayNativeHdrCreateInfoAMD* forUnmarshaling);
#define OP_vkSetLocalDimmingAMD 267533472
@@ -5073,10 +6029,12 @@
#ifdef VK_FUCHSIA_imagepipe_surface
void marshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling);
void unmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkImagePipeSurfaceCreateInfoFUCHSIA* forUnmarshaling);
#define OP_vkCreateImagePipeSurfaceFUCHSIA 261626137
@@ -5084,41 +6042,47 @@
#ifdef VK_EXT_metal_surface
void marshal_VkMetalSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMetalSurfaceCreateInfoEXT* forMarshaling);
void unmarshal_VkMetalSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMetalSurfaceCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateMetalSurfaceEXT 254915953
#endif
-#ifdef VK_GOOGLE_color_buffer
-void marshal_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
VulkanStreamGuest* vkStream,
- const VkImportColorBufferGOOGLE* forMarshaling);
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling);
-void unmarshal_VkImportColorBufferGOOGLE(
+void unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
VulkanStreamGuest* vkStream,
- VkImportColorBufferGOOGLE* forUnmarshaling);
+ VkStructureType rootType,
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forUnmarshaling);
-void marshal_VkImportBufferGOOGLE(
+void marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
VulkanStreamGuest* vkStream,
- const VkImportBufferGOOGLE* forMarshaling);
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling);
-void unmarshal_VkImportBufferGOOGLE(
+void unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
VulkanStreamGuest* vkStream,
- VkImportBufferGOOGLE* forUnmarshaling);
+ VkStructureType rootType,
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forUnmarshaling);
-void marshal_VkImportPhysicalAddressGOOGLE(
+void marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
VulkanStreamGuest* vkStream,
- const VkImportPhysicalAddressGOOGLE* forMarshaling);
+ VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling);
-void unmarshal_VkImportPhysicalAddressGOOGLE(
+void unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
VulkanStreamGuest* vkStream,
- VkImportPhysicalAddressGOOGLE* forUnmarshaling);
+ VkStructureType rootType,
+ VkRenderPassFragmentDensityMapCreateInfoEXT* forUnmarshaling);
-#define OP_vkRegisterImageColorBufferGOOGLE 20318
-#define OP_vkRegisterBufferColorBufferGOOGLE 20319
#endif
#ifdef VK_EXT_scalar_block_layout
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceScalarBlockLayoutFeatures, marshal_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT);
@@ -5133,104 +6097,126 @@
#ifdef VK_EXT_subgroup_size_control
void marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_AMD_shader_core_properties2
void marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderCoreProperties2AMD* forUnmarshaling);
#endif
#ifdef VK_AMD_device_coherent_memory
void marshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling);
void unmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCoherentMemoryFeaturesAMD* forUnmarshaling);
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void marshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_memory_budget
void marshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMemoryBudgetPropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_memory_priority
void marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceMemoryPriorityFeaturesEXT* forUnmarshaling);
void marshal_VkMemoryPriorityAllocateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryPriorityAllocateInfoEXT* forMarshaling);
void unmarshal_VkMemoryPriorityAllocateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkMemoryPriorityAllocateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void marshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_EXT_buffer_device_address
void marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, marshal_VkPhysicalDeviceBufferAddressFeaturesEXT);
@@ -5243,10 +6229,12 @@
void marshal_VkBufferDeviceAddressCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferDeviceAddressCreateInfoEXT* forMarshaling);
void unmarshal_VkBufferDeviceAddressCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBufferDeviceAddressCreateInfoEXT* forUnmarshaling);
#define OP_vkGetBufferDeviceAddressEXT 224361693
@@ -5254,10 +6242,12 @@
#ifdef VK_EXT_tooling_info
void marshal_VkPhysicalDeviceToolPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceToolPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceToolPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling);
#define OP_vkGetPhysicalDeviceToolPropertiesEXT 282247593
@@ -5271,36 +6261,44 @@
#ifdef VK_EXT_validation_features
void marshal_VkValidationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationFeaturesEXT* forMarshaling);
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 unmarshal_VkCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCooperativeMatrixPropertiesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCooperativeMatrixFeaturesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCooperativeMatrixPropertiesNV* forUnmarshaling);
#define OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV 287711429
@@ -5308,26 +6306,32 @@
#ifdef VK_NV_coverage_reduction_mode
void marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCoverageReductionModeFeaturesNV* forUnmarshaling);
void marshal_VkPipelineCoverageReductionStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineCoverageReductionStateCreateInfoNV* forUnmarshaling);
void marshal_VkFramebufferMixedSamplesCombinationNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* forMarshaling);
void unmarshal_VkFramebufferMixedSamplesCombinationNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkFramebufferMixedSamplesCombinationNV* forUnmarshaling);
#define OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV 292032159
@@ -5335,38 +6339,46 @@
#ifdef VK_EXT_fragment_shader_interlock
void marshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_full_screen_exclusive
void marshal_VkSurfaceFullScreenExclusiveInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling);
void unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceFullScreenExclusiveInfoEXT* forUnmarshaling);
void marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling);
void unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceCapabilitiesFullScreenExclusiveEXT* forUnmarshaling);
#define OP_vkGetPhysicalDeviceSurfacePresentModes2EXT 268126279
@@ -5374,10 +6386,12 @@
#define OP_vkReleaseFullScreenExclusiveModeEXT 257629142
void marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling);
void unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSurfaceFullScreenExclusiveWin32InfoEXT* forUnmarshaling);
#define OP_vkGetDeviceGroupSurfacePresentModes2EXT 206369543
@@ -5385,10 +6399,12 @@
#ifdef VK_EXT_headless_surface
void marshal_VkHeadlessSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkHeadlessSurfaceCreateInfoEXT* forMarshaling);
void unmarshal_VkHeadlessSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkHeadlessSurfaceCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateHeadlessSurfaceEXT 298411290
@@ -5396,26 +6412,32 @@
#ifdef VK_EXT_line_rasterization
void marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceLineRasterizationFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceLineRasterizationPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationLineStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineRasterizationLineStateCreateInfoEXT* forUnmarshaling);
#define OP_vkCmdSetLineStippleEXT 263855692
@@ -5423,10 +6445,12 @@
#ifdef VK_EXT_shader_atomic_float
void marshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forUnmarshaling);
#endif
@@ -5440,20 +6464,24 @@
#ifdef VK_EXT_index_type_uint8
void marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_extended_dynamic_state
void marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forUnmarshaling);
#define OP_vkCmdSetCullModeEXT 266285895
@@ -5472,116 +6500,144 @@
#ifdef VK_EXT_shader_demote_to_helper_invocation
void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_NV_device_generated_commands
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forUnmarshaling);
void marshal_VkGraphicsShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsShaderGroupCreateInfoNV* forMarshaling);
void unmarshal_VkGraphicsShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGraphicsShaderGroupCreateInfoNV* forUnmarshaling);
void marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling);
void unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGraphicsPipelineShaderGroupsCreateInfoNV* forUnmarshaling);
void marshal_VkBindShaderGroupIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindShaderGroupIndirectCommandNV* forMarshaling);
void unmarshal_VkBindShaderGroupIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindShaderGroupIndirectCommandNV* forUnmarshaling);
void marshal_VkBindIndexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindIndexBufferIndirectCommandNV* forMarshaling);
void unmarshal_VkBindIndexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindIndexBufferIndirectCommandNV* forUnmarshaling);
void marshal_VkBindVertexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindVertexBufferIndirectCommandNV* forMarshaling);
void unmarshal_VkBindVertexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkBindVertexBufferIndirectCommandNV* forUnmarshaling);
void marshal_VkSetStateFlagsIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSetStateFlagsIndirectCommandNV* forMarshaling);
void unmarshal_VkSetStateFlagsIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSetStateFlagsIndirectCommandNV* forUnmarshaling);
void marshal_VkIndirectCommandsStreamNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIndirectCommandsStreamNV* forMarshaling);
void unmarshal_VkIndirectCommandsStreamNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkIndirectCommandsStreamNV* forUnmarshaling);
void marshal_VkIndirectCommandsLayoutTokenNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutTokenNV* forMarshaling);
void unmarshal_VkIndirectCommandsLayoutTokenNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkIndirectCommandsLayoutTokenNV* forUnmarshaling);
void marshal_VkIndirectCommandsLayoutCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling);
void unmarshal_VkIndirectCommandsLayoutCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkIndirectCommandsLayoutCreateInfoNV* forUnmarshaling);
void marshal_VkGeneratedCommandsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeneratedCommandsInfoNV* forMarshaling);
void unmarshal_VkGeneratedCommandsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeneratedCommandsInfoNV* forUnmarshaling);
void marshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling);
void unmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkGeneratedCommandsMemoryRequirementsInfoNV* forUnmarshaling);
#define OP_vkGetGeneratedCommandsMemoryRequirementsNV 249047049
@@ -5594,106 +6650,130 @@
#ifdef VK_EXT_texel_buffer_alignment
void marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_QCOM_render_pass_transform
void marshal_VkRenderPassTransformBeginInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassTransformBeginInfoQCOM* forMarshaling);
void unmarshal_VkRenderPassTransformBeginInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRenderPassTransformBeginInfoQCOM* forUnmarshaling);
void marshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling);
void unmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forUnmarshaling);
#endif
#ifdef VK_EXT_device_memory_report
void marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forUnmarshaling);
void marshal_VkDeviceMemoryReportCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryReportCallbackDataEXT* forMarshaling);
void unmarshal_VkDeviceMemoryReportCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceMemoryReportCallbackDataEXT* forUnmarshaling);
void marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling);
void unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceDeviceMemoryReportCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_robustness2
void marshal_VkPhysicalDeviceRobustness2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRobustness2FeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceRobustness2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRobustness2PropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_custom_border_color
void marshal_VkSamplerCustomBorderColorCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling);
void unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkSamplerCustomBorderColorCreateInfoEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCustomBorderColorPropertiesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceCustomBorderColorFeaturesEXT* forUnmarshaling);
#endif
@@ -5702,26 +6782,32 @@
#ifdef VK_EXT_private_data
void marshal_VkPhysicalDevicePrivateDataFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling);
void marshal_VkDevicePrivateDataCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDevicePrivateDataCreateInfoEXT* forMarshaling);
void unmarshal_VkDevicePrivateDataCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDevicePrivateDataCreateInfoEXT* forUnmarshaling);
void marshal_VkPrivateDataSlotCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPrivateDataSlotCreateInfoEXT* forMarshaling);
void unmarshal_VkPrivateDataSlotCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPrivateDataSlotCreateInfoEXT* forUnmarshaling);
#define OP_vkCreatePrivateDataSlotEXT 236374049
@@ -5732,28 +6818,34 @@
#ifdef VK_EXT_pipeline_creation_cache_control
void marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_NV_device_diagnostics_config
void marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling);
void marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling);
void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling);
#endif
@@ -5762,26 +6854,32 @@
#ifdef VK_NV_fragment_shading_rate_enums
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forUnmarshaling);
void marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forUnmarshaling);
#define OP_vkCmdSetFragmentShadingRateEnumNV 264649847
@@ -5789,64 +6887,108 @@
#ifdef VK_EXT_fragment_density_map2
void marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_QCOM_rotated_copy_commands
void marshal_VkCopyCommandTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyCommandTransformInfoQCOM* forMarshaling);
void unmarshal_VkCopyCommandTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyCommandTransformInfoQCOM* forUnmarshaling);
#endif
#ifdef VK_EXT_image_robustness
void marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_4444_formats
void marshal_VkPhysicalDevice4444FormatsFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDevice4444FormatsFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_directfb_surface
void marshal_VkDirectFBSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDirectFBSurfaceCreateInfoEXT* forMarshaling);
void unmarshal_VkDirectFBSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDirectFBSurfaceCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateDirectFBSurfaceEXT 220792403
#define OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT 285441990
#endif
#ifdef VK_GOOGLE_gfxstream
+void marshal_VkImportColorBufferGOOGLE(
+ VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* forMarshaling);
+
+void unmarshal_VkImportColorBufferGOOGLE(
+ VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportColorBufferGOOGLE* forUnmarshaling);
+
+void marshal_VkImportBufferGOOGLE(
+ VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImportBufferGOOGLE* forMarshaling);
+
+void unmarshal_VkImportBufferGOOGLE(
+ VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportBufferGOOGLE* forUnmarshaling);
+
+void marshal_VkImportPhysicalAddressGOOGLE(
+ VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* forMarshaling);
+
+void unmarshal_VkImportPhysicalAddressGOOGLE(
+ VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportPhysicalAddressGOOGLE* forUnmarshaling);
+
+#define OP_vkRegisterImageColorBufferGOOGLE 20318
+#define OP_vkRegisterBufferColorBufferGOOGLE 20319
#define OP_vkMapMemoryIntoAddressSpaceGOOGLE 20317
#define OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE 20320
#define OP_vkBeginCommandBufferAsyncGOOGLE 20321
@@ -5869,154 +7011,192 @@
#ifdef VK_KHR_acceleration_structure
void marshal_VkDeviceOrHostAddressKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceOrHostAddressKHR* forMarshaling);
void unmarshal_VkDeviceOrHostAddressKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceOrHostAddressKHR* forUnmarshaling);
void marshal_VkDeviceOrHostAddressConstKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceOrHostAddressConstKHR* forMarshaling);
void unmarshal_VkDeviceOrHostAddressConstKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkDeviceOrHostAddressConstKHR* forUnmarshaling);
void marshal_VkAccelerationStructureBuildRangeInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureBuildRangeInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureBuildRangeInfoKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryTrianglesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureGeometryTrianglesDataKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryAabbsDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryAabbsDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureGeometryAabbsDataKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryInstancesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureGeometryInstancesDataKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryDataKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureGeometryDataKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureGeometryKHR* forUnmarshaling);
void marshal_VkAccelerationStructureBuildGeometryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureBuildGeometryInfoKHR* forUnmarshaling);
void marshal_VkAccelerationStructureCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureCreateInfoKHR* forUnmarshaling);
void marshal_VkWriteDescriptorSetAccelerationStructureKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling);
void unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkWriteDescriptorSetAccelerationStructureKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceAccelerationStructureFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceAccelerationStructurePropertiesKHR* forUnmarshaling);
void marshal_VkAccelerationStructureDeviceAddressInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureDeviceAddressInfoKHR* forUnmarshaling);
void marshal_VkAccelerationStructureVersionInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureVersionInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureVersionInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureVersionInfoKHR* forUnmarshaling);
void marshal_VkCopyAccelerationStructureToMemoryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling);
void unmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyAccelerationStructureToMemoryInfoKHR* forUnmarshaling);
void marshal_VkCopyMemoryToAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling);
void unmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyMemoryToAccelerationStructureInfoKHR* forUnmarshaling);
void marshal_VkCopyAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyAccelerationStructureInfoKHR* forMarshaling);
void unmarshal_VkCopyAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkCopyAccelerationStructureInfoKHR* forUnmarshaling);
void marshal_VkAccelerationStructureBuildSizesInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureBuildSizesInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkAccelerationStructureBuildSizesInfoKHR* forUnmarshaling);
#define OP_vkCreateAccelerationStructureKHR 259403971
@@ -6039,58 +7219,72 @@
#ifdef VK_KHR_ray_tracing_pipeline
void marshal_VkRayTracingShaderGroupCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling);
void unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling);
void marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling);
void unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling);
void marshal_VkRayTracingPipelineCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoKHR* forMarshaling);
void unmarshal_VkRayTracingPipelineCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkRayTracingPipelineCreateInfoKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling);
void marshal_VkStridedDeviceAddressRegionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStridedDeviceAddressRegionKHR* forMarshaling);
void unmarshal_VkStridedDeviceAddressRegionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkStridedDeviceAddressRegionKHR* forUnmarshaling);
void marshal_VkTraceRaysIndirectCommandKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTraceRaysIndirectCommandKHR* forMarshaling);
void unmarshal_VkTraceRaysIndirectCommandKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkTraceRaysIndirectCommandKHR* forUnmarshaling);
#define OP_vkCmdTraceRaysKHR 213680716
@@ -6103,10 +7297,12 @@
#ifdef VK_KHR_ray_query
void marshal_VkPhysicalDeviceRayQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
VkPhysicalDeviceRayQueryFeaturesKHR* forUnmarshaling);
#endif
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
index 38f98f7..bf57d8a 100644
--- a/system/vulkan_enc/goldfish_vk_private_defs.h
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -87,13 +87,13 @@
typedef VkResult (VKAPI_PTR *PFN_vkMapMemoryIntoAddressSpaceGOOGLE)(VkDevice device, VkDeviceMemory memory, uint64_t* pAddress);
-#define VK_GOOGLE_color_buffer 1
-#define VK_GOOGLE_COLOR_BUFFER_EXTENSION_NUMBER 219
+#define VK_GOOGLE_gfxstream 1
+#define VK_GOOGLE_GFXSTREAM_EXTENSION_NUMBER 386
-#define VK_GOOGLE_COLOR_BUFFER_ENUM(type,id) ((type)(1000000000 + (1000 * (VK_GOOGLE_COLOR_BUFFER_EXTENSION_NUMBER - 1)) + (id)))
-#define VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE VK_GOOGLE_COLOR_BUFFER_ENUM(VkStructureType, 0)
-#define VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE VK_GOOGLE_COLOR_BUFFER_ENUM(VkStructureType, 1)
-#define VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE VK_GOOGLE_COLOR_BUFFER_ENUM(VkStructureType, 2)
+#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
@@ -533,14 +533,44 @@
#define VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA \
((VkStructureType)1001004008)
+
+#if VK_HEADER_VERSION < 174
+#define VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA \
+ ((VkStructureType)1000364000)
+#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA \
+ ((VkExternalMemoryHandleTypeFlagBits)0x00000800)
+#endif
+
+// Deprecated
#define VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA \
((VkStructureType)1001005000)
-#define VK_STRUCTURE_TYPE_TEMP_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA \
- ((VkStructureType)1001005001)
#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA \
((VkExternalMemoryHandleTypeFlagBits)0x00100000)
+
+#else // VK_FUCHSIA_external_memory
+
+// For backward compatibility
+#if VK_HEADER_VERSION >= 174
+#define VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA \
+ ((VkStructureType)1001005000)
+#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA \
+ ((VkExternalMemoryHandleTypeFlagBits)0x00100000)
+#endif // VK_HEADER_VERSION >= 174
+
+// For forward compatibility
+#ifndef VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA
+#define VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA ((VkStructureType)1000364000)
+#endif // VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA
+
+// For forward compatibility
+#ifndef VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA
+#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA \
+ ((VkExternalMemoryHandleTypeFlagBits)0x00000800)
+#endif // VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA
+
#endif // VK_FUCHSIA_external_memory
+
#ifndef VK_FUCHSIA_external_semaphore
#define VK_FUCHSIA_external_semaphore 1
#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
@@ -552,7 +582,11 @@
VkSemaphore semaphore;
VkSemaphoreImportFlags flags;
VkExternalSemaphoreHandleTypeFlagBits handleType;
+#if VK_HEADER_VERSION < 174
uint32_t handle;
+#else // VK_HEADER_VERSION >= 174
+ uint32_t zirconHandle;
+#endif // VK_HEADER_VERSION < 174
} VkImportSemaphoreZirconHandleInfoFUCHSIA;
typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA {
@@ -562,10 +596,32 @@
VkExternalSemaphoreHandleTypeFlagBits handleType;
} VkSemaphoreGetZirconHandleInfoFUCHSIA;
+#if VK_HEADER_VERSION < 174
+#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA \
+ ((VkExternalMemoryHandleTypeFlagBits)0x00000080)
+#endif
+
+// Deprecated
#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA \
((VkExternalSemaphoreHandleTypeFlagBits)0x00100000)
+
+#else // VK_FUCHSIA_external_semaphore
+
+// For backward compatibility
+#if VK_HEADER_VERSION >= 174
+#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA \
+ ((VkExternalSemaphoreHandleTypeFlagBits)0x00100000)
+#endif // VK_HEADER_VERSION >= 174
+
+// For forward compatibility
+#ifndef VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA
+#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA \
+ ((VkExternalMemoryHandleTypeFlagBits)0x00000080)
+#endif // VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA
+
#endif // VK_FUCHSIA_external_semaphore
+
// VulkanStream features
#define VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT (1 << 0)
#define VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT (1 << 1)
diff --git a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
index 5d933b2..e4bf00d 100644
--- a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
@@ -35,21 +35,25 @@
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);
#ifdef VK_VERSION_1_0
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->height, sizeof(uint32_t));
@@ -58,10 +62,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->height, sizeof(uint32_t));
@@ -72,10 +78,12 @@
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));
*ptr += sizeof(int32_t);
memcpy(*ptr, (int32_t*)&forMarshaling->y, sizeof(int32_t));
@@ -84,10 +92,12 @@
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));
*ptr += sizeof(int32_t);
memcpy(*ptr, (int32_t*)&forMarshaling->y, sizeof(int32_t));
@@ -98,45 +108,65 @@
void reservedmarshal_VkRect2D(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRect2D* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->offset), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->extent), ptr);
+ (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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
*ptr += sizeof(VkAccessFlags);
memcpy(*ptr, (VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
@@ -157,10 +187,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->y, sizeof(uint32_t));
@@ -171,10 +203,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
@@ -189,10 +223,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
@@ -205,10 +241,12 @@
void reservedmarshal_VkImageSubresourceRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSubresourceRange* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
*ptr += sizeof(VkImageAspectFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->baseMipLevel, sizeof(uint32_t));
@@ -223,13 +261,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
*ptr += sizeof(VkAccessFlags);
memcpy(*ptr, (VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
@@ -246,18 +290,24 @@
*&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- reservedmarshal_VkImageSubresourceRange(vkStream, (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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
*ptr += sizeof(VkAccessFlags);
memcpy(*ptr, (VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
@@ -266,10 +316,12 @@
void reservedmarshal_VkAllocationCallbacks(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAllocationCallbacks* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
memcpy((*ptr), &cgen_var_0, 8);
@@ -304,13 +356,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
{
// WARNING PTR CHECK
@@ -381,10 +439,12 @@
void reservedmarshal_VkFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFormatProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags));
@@ -395,11 +455,13 @@
void reservedmarshal_VkImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageFormatProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->maxExtent), ptr);
+ (void)rootType;
+ reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->maxExtent), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxMipLevels, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxArrayLayers, sizeof(uint32_t));
@@ -412,13 +474,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkInstanceCreateFlags*)&forMarshaling->flags, sizeof(VkInstanceCreateFlags));
*ptr += sizeof(VkInstanceCreateFlags);
// WARNING PTR CHECK
@@ -428,7 +496,7 @@
*ptr += 8;
if (forMarshaling->pApplicationInfo)
{
- reservedmarshal_VkApplicationInfo(vkStream, (const VkApplicationInfo*)(forMarshaling->pApplicationInfo), ptr);
+ reservedmarshal_VkApplicationInfo(vkStream, rootType, (const VkApplicationInfo*)(forMarshaling->pApplicationInfo), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -482,10 +550,12 @@
void reservedmarshal_VkMemoryHeap(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryHeap* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkMemoryHeapFlags*)&forMarshaling->flags, sizeof(VkMemoryHeapFlags));
@@ -494,10 +564,12 @@
void reservedmarshal_VkMemoryType(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryType* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkMemoryPropertyFlags*)&forMarshaling->propertyFlags, sizeof(VkMemoryPropertyFlags));
*ptr += sizeof(VkMemoryPropertyFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->heapIndex, sizeof(uint32_t));
@@ -506,10 +578,12 @@
void reservedmarshal_VkPhysicalDeviceFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkBool32*)&forMarshaling->robustBufferAccess, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->fullDrawIndexUint32, sizeof(VkBool32));
@@ -624,10 +698,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageDimension2D, sizeof(uint32_t));
@@ -846,30 +922,34 @@
void reservedmarshal_VkPhysicalDeviceMemoryProperties(
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, (VkMemoryType*)(forMarshaling->memoryTypes + i), ptr);
+ 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, (VkMemoryHeap*)(forMarshaling->memoryHeaps + i), ptr);
+ reservedmarshal_VkMemoryHeap(vkStream, rootType, (VkMemoryHeap*)(forMarshaling->memoryHeaps + i), ptr);
}
}
void reservedmarshal_VkPhysicalDeviceSparseProperties(
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));
@@ -884,10 +964,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->driverVersion, sizeof(uint32_t));
@@ -902,34 +984,42 @@
*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, (VkPhysicalDeviceLimits*)(&forMarshaling->limits), ptr);
- reservedmarshal_VkPhysicalDeviceSparseProperties(vkStream, (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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkQueueFlags*)&forMarshaling->queueFlags, sizeof(VkQueueFlags));
*ptr += sizeof(VkQueueFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->timestampValidBits, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkExtent3D(vkStream, (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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceQueueCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
@@ -942,20 +1032,26 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceCreateFlags));
*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, (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i), ptr);
+ reservedmarshal_VkDeviceQueueCreateInfo(vkStream, rootType, (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -1012,16 +1108,18 @@
*ptr += 8;
if (forMarshaling->pEnabledFeatures)
{
- reservedmarshal_VkPhysicalDeviceFeatures(vkStream, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures), ptr);
+ reservedmarshal_VkPhysicalDeviceFeatures(vkStream, rootType, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures), 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));
*ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
memcpy(*ptr, (uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
@@ -1030,10 +1128,12 @@
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));
*ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
memcpy(*ptr, (uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
@@ -1046,13 +1146,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
@@ -1104,13 +1210,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1123,13 +1235,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeIndex, sizeof(uint32_t));
@@ -1138,10 +1256,12 @@
void reservedmarshal_VkMemoryRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryRequirements* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->alignment, sizeof(VkDeviceSize));
@@ -1152,10 +1272,12 @@
void reservedmarshal_VkSparseMemoryBind(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseMemoryBind* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->resourceOffset, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
@@ -1172,10 +1294,12 @@
void reservedmarshal_VkSparseBufferMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseBufferMemoryBindInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1184,16 +1308,18 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
- reservedmarshal_VkSparseMemoryBind(vkStream, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
+ reservedmarshal_VkSparseMemoryBind(vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
}
}
void reservedmarshal_VkSparseImageOpaqueMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageOpaqueMemoryBindInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1202,16 +1328,18 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
- reservedmarshal_VkSparseMemoryBind(vkStream, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
+ reservedmarshal_VkSparseMemoryBind(vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), 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));
*ptr += sizeof(VkImageAspectFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
@@ -1222,13 +1350,15 @@
void reservedmarshal_VkSparseImageMemoryBind(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryBind* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forMarshaling->subresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->offset), ptr);
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent), ptr);
+ (void)rootType;
+ 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;
*&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1241,10 +1371,12 @@
void reservedmarshal_VkSparseImageMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryBindInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1253,19 +1385,25 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
- reservedmarshal_VkSparseImageMemoryBind(vkStream, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i), ptr);
+ reservedmarshal_VkSparseImageMemoryBind(vkStream, rootType, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
@@ -1285,19 +1423,19 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i)
{
- reservedmarshal_VkSparseBufferMemoryBindInfo(vkStream, (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i), ptr);
+ 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, (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i), ptr);
+ 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, (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i), ptr);
+ reservedmarshal_VkSparseImageMemoryBindInfo(vkStream, rootType, (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -1318,24 +1456,28 @@
void reservedmarshal_VkSparseImageFormatProperties(
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, (VkExtent3D*)(&forMarshaling->imageGranularity), ptr);
+ 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)
{
(void)vkStream;
- reservedmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties), ptr);
+ (void)rootType;
+ 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));
@@ -1348,52 +1490,76 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkFenceCreateFlags*)&forMarshaling->flags, sizeof(VkFenceCreateFlags));
*ptr += sizeof(VkFenceCreateFlags);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkSemaphoreCreateFlags*)&forMarshaling->flags, sizeof(VkSemaphoreCreateFlags));
*ptr += sizeof(VkSemaphoreCreateFlags);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkEventCreateFlags*)&forMarshaling->flags, sizeof(VkEventCreateFlags));
*ptr += sizeof(VkEventCreateFlags);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkQueryPoolCreateFlags*)&forMarshaling->flags, sizeof(VkQueryPoolCreateFlags));
*ptr += sizeof(VkQueryPoolCreateFlags);
memcpy(*ptr, (VkQueryType*)&forMarshaling->queryType, sizeof(VkQueryType));
@@ -1406,13 +1572,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
*ptr += sizeof(VkBufferCreateFlags);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
@@ -1437,13 +1609,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBufferViewCreateFlags*)&forMarshaling->flags, sizeof(VkBufferViewCreateFlags));
*ptr += sizeof(VkBufferViewCreateFlags);
uint64_t cgen_var_0;
@@ -1460,20 +1638,26 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
*ptr += sizeof(VkImageCreateFlags);
memcpy(*ptr, (VkImageType*)&forMarshaling->imageType, sizeof(VkImageType));
*ptr += sizeof(VkImageType);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent), ptr);
+ reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->mipLevels, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->arrayLayers, sizeof(uint32_t));
@@ -1504,10 +1688,12 @@
void reservedmarshal_VkSubresourceLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubresourceLayout* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
@@ -1522,10 +1708,12 @@
void reservedmarshal_VkComponentMapping(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkComponentMapping* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkComponentSwizzle*)&forMarshaling->r, sizeof(VkComponentSwizzle));
*ptr += sizeof(VkComponentSwizzle);
memcpy(*ptr, (VkComponentSwizzle*)&forMarshaling->g, sizeof(VkComponentSwizzle));
@@ -1538,13 +1726,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageViewCreateFlags*)&forMarshaling->flags, sizeof(VkImageViewCreateFlags));
*ptr += sizeof(VkImageViewCreateFlags);
uint64_t cgen_var_0;
@@ -1555,19 +1749,25 @@
*ptr += sizeof(VkImageViewType);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
- reservedmarshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forMarshaling->components), ptr);
- reservedmarshal_VkImageSubresourceRange(vkStream, (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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkShaderModuleCreateFlags);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->codeSize;
@@ -1580,13 +1780,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineCacheCreateFlags);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
@@ -1599,10 +1805,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
@@ -1615,15 +1823,17 @@
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, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i), ptr);
+ 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);
@@ -1635,13 +1845,19 @@
void reservedmarshal_VkPipelineShaderStageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineShaderStageCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineShaderStageCreateFlags);
memcpy(*ptr, (VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
@@ -1665,22 +1881,28 @@
*ptr += 8;
if (forMarshaling->pSpecializationInfo)
{
- reservedmarshal_VkSpecializationInfo(vkStream, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo), ptr);
+ reservedmarshal_VkSpecializationInfo(vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (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);
@@ -1695,10 +1917,12 @@
void reservedmarshal_VkVertexInputBindingDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputBindingDescription* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
@@ -1709,10 +1933,12 @@
void reservedmarshal_VkVertexInputAttributeDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputAttributeDescription* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->location, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
@@ -1725,38 +1951,50 @@
void reservedmarshal_VkPipelineVertexInputStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineVertexInputStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*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, (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i), ptr);
+ 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, (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions + i), ptr);
+ reservedmarshal_VkVertexInputAttributeDescription(vkStream, rootType, (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions + i), ptr);
}
}
void reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineInputAssemblyStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineInputAssemblyStateCreateFlags);
memcpy(*ptr, (VkPrimitiveTopology*)&forMarshaling->topology, sizeof(VkPrimitiveTopology));
@@ -1767,13 +2005,19 @@
void reservedmarshal_VkPipelineTessellationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineTessellationStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineTessellationStateCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
@@ -1782,10 +2026,12 @@
void reservedmarshal_VkViewport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkViewport* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (float*)&forMarshaling->x, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->y, sizeof(float));
@@ -1802,13 +2048,19 @@
void reservedmarshal_VkPipelineViewportStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineViewportStateCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
@@ -1822,7 +2074,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
{
- reservedmarshal_VkViewport(vkStream, (const VkViewport*)(forMarshaling->pViewports + i), ptr);
+ reservedmarshal_VkViewport(vkStream, rootType, (const VkViewport*)(forMarshaling->pViewports + i), ptr);
}
}
memcpy(*ptr, (uint32_t*)&forMarshaling->scissorCount, sizeof(uint32_t));
@@ -1836,20 +2088,26 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i)
{
- reservedmarshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pScissors + i), ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pScissors + i), ptr);
}
}
}
void reservedmarshal_VkPipelineRasterizationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineRasterizationStateCreateFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->depthClampEnable, sizeof(VkBool32));
@@ -1876,13 +2134,19 @@
void reservedmarshal_VkPipelineMultisampleStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineMultisampleStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineMultisampleStateCreateFlags);
memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
@@ -1909,10 +2173,12 @@
void reservedmarshal_VkStencilOpState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStencilOpState* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStencilOp*)&forMarshaling->failOp, sizeof(VkStencilOp));
*ptr += sizeof(VkStencilOp);
memcpy(*ptr, (VkStencilOp*)&forMarshaling->passOp, sizeof(VkStencilOp));
@@ -1931,13 +2197,19 @@
void reservedmarshal_VkPipelineDepthStencilStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDepthStencilStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineDepthStencilStateCreateFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->depthTestEnable, sizeof(VkBool32));
@@ -1950,8 +2222,8 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->stencilTestEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- reservedmarshal_VkStencilOpState(vkStream, (VkStencilOpState*)(&forMarshaling->front), ptr);
- reservedmarshal_VkStencilOpState(vkStream, (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));
@@ -1960,10 +2232,12 @@
void reservedmarshal_VkPipelineColorBlendAttachmentState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendAttachmentState* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkBool32*)&forMarshaling->blendEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
@@ -1984,13 +2258,19 @@
void reservedmarshal_VkPipelineColorBlendStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineColorBlendStateCreateFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->logicOpEnable, sizeof(VkBool32));
@@ -2001,7 +2281,7 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
{
- reservedmarshal_VkPipelineColorBlendAttachmentState(vkStream, (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i), ptr);
+ reservedmarshal_VkPipelineColorBlendAttachmentState(vkStream, rootType, (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i), ptr);
}
memcpy(*ptr, (float*)forMarshaling->blendConstants, 4 * sizeof(float));
*ptr += 4 * sizeof(float);
@@ -2009,13 +2289,19 @@
void reservedmarshal_VkPipelineDynamicStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDynamicStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineDynamicStateCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->dynamicStateCount, sizeof(uint32_t));
@@ -2026,10 +2312,12 @@
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)
{
@@ -2050,14 +2338,18 @@
}
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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);
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, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
+ reservedmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
}
// WARNING PTR CHECK
if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
@@ -2069,7 +2361,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pVertexInputState))
{
- reservedmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
+ reservedmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
}
// WARNING PTR CHECK
if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
@@ -2081,7 +2373,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pInputAssemblyState))
{
- reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState), ptr);
+ reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, rootType, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
@@ -2092,7 +2384,7 @@
{
if (hasTessellation)
{
- reservedmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState), ptr);
+ reservedmarshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState), ptr);
}
}
// WARNING PTR CHECK
@@ -2104,7 +2396,7 @@
{
if (hasRasterization)
{
- reservedmarshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState), ptr);
+ reservedmarshal_VkPipelineViewportStateCreateInfo(vkStream, rootType, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState), ptr);
}
}
// WARNING PTR CHECK
@@ -2117,7 +2409,7 @@
}
if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pRasterizationState))
{
- reservedmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState), ptr);
+ reservedmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, rootType, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
@@ -2128,7 +2420,7 @@
{
if (hasRasterization)
{
- reservedmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState), ptr);
+ reservedmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, rootType, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState), ptr);
}
}
// WARNING PTR CHECK
@@ -2140,7 +2432,7 @@
{
if (hasRasterization)
{
- reservedmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState), ptr);
+ reservedmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, rootType, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState), ptr);
}
}
// WARNING PTR CHECK
@@ -2152,7 +2444,7 @@
{
if (hasRasterization)
{
- reservedmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState), ptr);
+ reservedmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, rootType, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState), ptr);
}
}
// WARNING PTR CHECK
@@ -2162,7 +2454,7 @@
*ptr += 8;
if (forMarshaling->pDynamicState)
{
- reservedmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
+ reservedmarshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
}
uint64_t cgen_var_6;
*&cgen_var_6 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
@@ -2184,10 +2476,12 @@
void reservedmarshal_VkPushConstantRange(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPushConstantRange* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
*ptr += sizeof(VkShaderStageFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
@@ -2198,13 +2492,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineLayoutCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
@@ -2226,19 +2526,25 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
{
- reservedmarshal_VkPushConstantRange(vkStream, (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i), ptr);
+ reservedmarshal_VkPushConstantRange(vkStream, rootType, (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkSamplerCreateFlags*)&forMarshaling->flags, sizeof(VkSamplerCreateFlags));
*ptr += sizeof(VkSamplerCreateFlags);
memcpy(*ptr, (VkFilter*)&forMarshaling->magFilter, sizeof(VkFilter));
@@ -2275,13 +2581,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDescriptorSet((*&forMarshaling->srcSet));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2304,10 +2616,12 @@
void reservedmarshal_VkDescriptorBufferInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorBufferInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2320,10 +2634,12 @@
void reservedmarshal_VkDescriptorImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorImageInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkSampler((*&forMarshaling->sampler));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2338,10 +2654,12 @@
void reservedmarshal_VkDescriptorPoolSize(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorPoolSize* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
*ptr += sizeof(VkDescriptorType);
memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
@@ -2350,13 +2668,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDescriptorPoolCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxSets, sizeof(uint32_t));
@@ -2365,19 +2689,25 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i)
{
- reservedmarshal_VkDescriptorPoolSize(vkStream, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i), ptr);
+ reservedmarshal_VkDescriptorPoolSize(vkStream, rootType, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDescriptorPool((*&forMarshaling->descriptorPool));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2401,10 +2731,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
@@ -2438,32 +2770,44 @@
void reservedmarshal_VkDescriptorSetLayoutCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*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, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i), ptr);
+ reservedmarshal_VkDescriptorSetLayoutBinding(vkStream, rootType, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDescriptorSet((*&forMarshaling->dstSet));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2487,7 +2831,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
{
- reservedmarshal_VkDescriptorImageInfo(vkStream, (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i), ptr);
+ reservedmarshal_VkDescriptorImageInfo(vkStream, rootType, (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i), ptr);
}
}
}
@@ -2502,7 +2846,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
{
- reservedmarshal_VkDescriptorBufferInfo(vkStream, (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i), ptr);
+ reservedmarshal_VkDescriptorBufferInfo(vkStream, rootType, (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i), ptr);
}
}
}
@@ -2534,10 +2878,12 @@
void reservedmarshal_VkAttachmentDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentDescription* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
*ptr += sizeof(VkAttachmentDescriptionFlags);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
@@ -2560,10 +2906,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
@@ -2572,13 +2920,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkFramebufferCreateFlags);
uint64_t cgen_var_0;
@@ -2610,10 +2964,12 @@
void reservedmarshal_VkSubpassDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDescription* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkSubpassDescriptionFlags*)&forMarshaling->flags, sizeof(VkSubpassDescriptionFlags));
*ptr += sizeof(VkSubpassDescriptionFlags);
memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
@@ -2622,13 +2978,13 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
{
- reservedmarshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i), ptr);
+ 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, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i), ptr);
+ reservedmarshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
@@ -2639,7 +2995,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
{
- reservedmarshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i), ptr);
+ reservedmarshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i), ptr);
}
}
// WARNING PTR CHECK
@@ -2649,7 +3005,7 @@
*ptr += 8;
if (forMarshaling->pDepthStencilAttachment)
{
- reservedmarshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment), ptr);
+ reservedmarshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -2659,10 +3015,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
@@ -2681,44 +3039,56 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
*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, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i), ptr);
+ 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, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i), ptr);
+ 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, (const VkSubpassDependency*)(forMarshaling->pDependencies + i), ptr);
+ reservedmarshal_VkSubpassDependency(vkStream, rootType, (const VkSubpassDependency*)(forMarshaling->pDependencies + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkCommandPoolCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
@@ -2727,13 +3097,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkCommandPool((*&forMarshaling->commandPool));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2746,13 +3122,19 @@
void reservedmarshal_VkCommandBufferInheritanceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkRenderPass((*&forMarshaling->renderPass));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2773,13 +3155,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkCommandBufferUsageFlags);
// WARNING PTR CHECK
@@ -2789,16 +3177,18 @@
*ptr += 8;
if (forMarshaling->pInheritanceInfo)
{
- reservedmarshal_VkCommandBufferInheritanceInfo(vkStream, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo), ptr);
+ reservedmarshal_VkCommandBufferInheritanceInfo(vkStream, rootType, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo), 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));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
@@ -2809,10 +3199,12 @@
void reservedmarshal_VkImageSubresourceLayers(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSubresourceLayers* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
*ptr += sizeof(VkImageAspectFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
@@ -2825,37 +3217,43 @@
void reservedmarshal_VkBufferImageCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferImageCopy* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->imageExtent), 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)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)vkStream;
+ (void)rootType;
memcpy(*ptr, (float*)&forMarshaling->depth, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (uint32_t*)&forMarshaling->stencil, sizeof(uint32_t));
@@ -2864,33 +3262,39 @@
void reservedmarshal_VkClearValue(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkClearValue* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forMarshaling->color), ptr);
+ (void)rootType;
+ reservedmarshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forMarshaling->color), 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, (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)vkStream;
- reservedmarshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->rect), ptr);
+ (void)rootType;
+ reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->rect), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
@@ -2899,57 +3303,69 @@
void reservedmarshal_VkImageBlit(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageBlit* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
+ (void)rootType;
+ reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->srcOffsets + i), ptr);
+ reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i), ptr);
}
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
for (uint32_t i = 0; i < (uint32_t)2; ++i)
{
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->dstOffsets + i), ptr);
+ reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i), ptr);
}
}
void reservedmarshal_VkImageCopy(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageCopy* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent), ptr);
+ (void)rootType;
+ 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_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)vkStream;
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent), ptr);
+ (void)rootType;
+ 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_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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkRenderPass((*&forMarshaling->renderPass));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2958,7 +3374,7 @@
*&cgen_var_1 = get_host_u64_VkFramebuffer((*&forMarshaling->framebuffer));
memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
*ptr += 1 * 8;
- reservedmarshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea), ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -2970,7 +3386,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
{
- reservedmarshal_VkClearValue(vkStream, (const VkClearValue*)(forMarshaling->pClearValues + i), ptr);
+ reservedmarshal_VkClearValue(vkStream, rootType, (const VkClearValue*)(forMarshaling->pClearValues + i), ptr);
}
}
}
@@ -2979,13 +3395,19 @@
#ifdef VK_VERSION_1_1
void reservedmarshal_VkPhysicalDeviceSubgroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->supportedStages, sizeof(VkShaderStageFlags));
@@ -2998,13 +3420,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkBuffer((*&forMarshaling->buffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3019,13 +3447,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3040,13 +3474,19 @@
void reservedmarshal_VkPhysicalDevice16BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice16BitStorageFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
@@ -3059,13 +3499,19 @@
void reservedmarshal_VkMemoryDedicatedRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryDedicatedRequirements* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
@@ -3074,13 +3520,19 @@
void reservedmarshal_VkMemoryDedicatedAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryDedicatedAllocateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3093,13 +3545,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkMemoryAllocateFlags*)&forMarshaling->flags, sizeof(VkMemoryAllocateFlags));
*ptr += sizeof(VkMemoryAllocateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
@@ -3108,45 +3566,63 @@
void reservedmarshal_VkDeviceGroupRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupRenderPassBeginInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
*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, (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i), ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i), ptr);
}
}
void reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupCommandBufferBeginInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -3163,13 +3639,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->resourceDeviceIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryDeviceIndex, sizeof(uint32_t));
@@ -3178,13 +3660,19 @@
void reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindBufferMemoryDeviceGroupInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -3193,13 +3681,19 @@
void reservedmarshal_VkBindImageMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemoryDeviceGroupInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -3208,19 +3702,25 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i)
{
- reservedmarshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i), ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i), ptr);
}
}
void reservedmarshal_VkPhysicalDeviceGroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceGroupProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -3231,13 +3731,19 @@
void reservedmarshal_VkDeviceGroupDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupDeviceCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
@@ -3257,13 +3763,19 @@
void reservedmarshal_VkBufferMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferMemoryRequirementsInfo2* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkBuffer((*&forMarshaling->buffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3272,13 +3784,19 @@
void reservedmarshal_VkImageMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageMemoryRequirementsInfo2* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3287,13 +3805,19 @@
void reservedmarshal_VkImageSparseMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSparseMemoryRequirementsInfo2* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3302,85 +3826,127 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements), ptr);
+ 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);
}
void reservedmarshal_VkSparseImageMemoryRequirements2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageMemoryRequirements2* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forMarshaling->features), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forMarshaling->properties), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forMarshaling->formatProperties), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties), ptr);
+ 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);
}
void reservedmarshal_VkPhysicalDeviceImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageFormatInfo2* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (VkImageType*)&forMarshaling->type, sizeof(VkImageType));
@@ -3395,49 +3961,73 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties), ptr);
+ 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);
}
void reservedmarshal_VkPhysicalDeviceMemoryProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties2* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties), ptr);
+ 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);
}
void reservedmarshal_VkSparseImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageFormatProperties2* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->properties), ptr);
+ 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);
}
void reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (VkImageType*)&forMarshaling->type, sizeof(VkImageType));
@@ -3452,23 +4042,31 @@
void reservedmarshal_VkPhysicalDevicePointClippingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePointClippingProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPointClippingBehavior);
}
void reservedmarshal_VkInputAttachmentAspectReference(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkInputAttachmentAspectReference* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->inputAttachmentIndex, sizeof(uint32_t));
@@ -3479,56 +4077,80 @@
void reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i), ptr);
+ reservedmarshal_VkInputAttachmentAspectReference(vkStream, rootType, (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
*ptr += sizeof(VkImageUsageFlags);
}
void reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkTessellationDomainOrigin);
}
void reservedmarshal_VkRenderPassMultiviewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassMultiviewCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -3545,13 +4167,19 @@
void reservedmarshal_VkPhysicalDeviceMultiviewFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->multiviewGeometryShader, sizeof(VkBool32));
@@ -3562,13 +4190,19 @@
void reservedmarshal_VkPhysicalDeviceMultiviewProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
@@ -3577,13 +4211,19 @@
void reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
@@ -3592,39 +4232,57 @@
void reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceQueueCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
@@ -3635,33 +4293,45 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->protectedSubmit, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkSamplerYcbcrConversionCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSamplerYcbcrModelConversion);
memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
*ptr += sizeof(VkSamplerYcbcrRange);
- reservedmarshal_VkComponentMapping(vkStream, (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));
@@ -3674,13 +4344,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSamplerYcbcrConversion((*&forMarshaling->conversion));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3689,62 +4365,88 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkImageAspectFlagBits);
}
void reservedmarshal_VkImagePlaneMemoryRequirementsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImagePlaneMemoryRequirementsInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkImageAspectFlagBits);
}
void reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkDescriptorUpdateTemplateEntry(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateEntry* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
@@ -3765,20 +4467,26 @@
void reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*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, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i), ptr);
+ reservedmarshal_VkDescriptorUpdateTemplateEntry(vkStream, rootType, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i), ptr);
}
memcpy(*ptr, (VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
*ptr += sizeof(VkDescriptorUpdateTemplateType);
@@ -3798,10 +4506,12 @@
void reservedmarshal_VkExternalMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlags));
*ptr += sizeof(VkExternalMemoryFeatureFlags);
memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
@@ -3812,38 +4522,56 @@
void reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
void reservedmarshal_VkExternalImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalImageFormatProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties), ptr);
+ 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);
}
void reservedmarshal_VkPhysicalDeviceExternalBufferInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalBufferInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
*ptr += sizeof(VkBufferCreateFlags);
memcpy(*ptr, (VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
@@ -3854,25 +4582,37 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint8_t*)forMarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
*ptr += VK_UUID_SIZE * sizeof(uint8_t);
memcpy(*ptr, (uint8_t*)forMarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
@@ -3887,65 +4627,95 @@
void reservedmarshal_VkExternalMemoryImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}
void reservedmarshal_VkExternalMemoryBufferCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryBufferCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}
void reservedmarshal_VkPhysicalDeviceExternalFenceInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalFenceInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalFenceHandleTypeFlags);
memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
@@ -3956,52 +4726,76 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalFenceHandleTypeFlags);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlags);
}
void reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}
void reservedmarshal_VkExternalSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalSemaphoreProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlags);
memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
@@ -4012,13 +4806,19 @@
void reservedmarshal_VkPhysicalDeviceMaintenance3Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMaintenance3Properties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerSetDescriptors, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
@@ -4027,26 +4827,38 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->supported, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -4055,13 +4867,19 @@
#ifdef VK_VERSION_1_2
void reservedmarshal_VkPhysicalDeviceVulkan11Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Features* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
@@ -4090,13 +4908,19 @@
void reservedmarshal_VkPhysicalDeviceVulkan11Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Properties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint8_t*)forMarshaling->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
*ptr += VK_UUID_SIZE * sizeof(uint8_t);
memcpy(*ptr, (uint8_t*)forMarshaling->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
@@ -4131,13 +4955,19 @@
void reservedmarshal_VkPhysicalDeviceVulkan12Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Features* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->samplerMirrorClampToEdge, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->drawIndirectCount, sizeof(VkBool32));
@@ -4236,10 +5066,12 @@
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));
*ptr += sizeof(uint8_t);
memcpy(*ptr, (uint8_t*)&forMarshaling->minor, sizeof(uint8_t));
@@ -4252,20 +5084,26 @@
void reservedmarshal_VkPhysicalDeviceVulkan12Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan12Properties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDriverId*)&forMarshaling->driverID, sizeof(VkDriverId));
*ptr += sizeof(VkDriverId);
memcpy(*ptr, (char*)forMarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
*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, (VkConformanceVersion*)(&forMarshaling->conformanceVersion), ptr);
+ 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));
@@ -4366,13 +5204,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -4381,13 +5225,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkAttachmentDescriptionFlags);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
@@ -4410,13 +5260,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
@@ -4427,13 +5283,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSubpassDescriptionFlags);
memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
@@ -4444,13 +5306,13 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
{
- reservedmarshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i), ptr);
+ 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, (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i), ptr);
+ reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
@@ -4461,7 +5323,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
{
- reservedmarshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i), ptr);
+ reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i), ptr);
}
}
// WARNING PTR CHECK
@@ -4471,7 +5333,7 @@
*ptr += 8;
if (forMarshaling->pDepthStencilAttachment)
{
- reservedmarshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilAttachment), ptr);
+ reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilAttachment), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -4481,13 +5343,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
@@ -4508,32 +5376,38 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
*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, (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i), ptr);
+ 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, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i), ptr);
+ 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, (const VkSubpassDependency2*)(forMarshaling->pDependencies + i), ptr);
+ reservedmarshal_VkSubpassDependency2(vkStream, rootType, (const VkSubpassDependency2*)(forMarshaling->pDependencies + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->correlatedViewMaskCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -4543,37 +5417,55 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkSubpassContents*)&forMarshaling->contents, sizeof(VkSubpassContents));
*ptr += sizeof(VkSubpassContents);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
@@ -4584,31 +5476,43 @@
void reservedmarshal_VkPhysicalDeviceDriverProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDriverProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDriverId*)&forMarshaling->driverID, sizeof(VkDriverId));
*ptr += sizeof(VkDriverId);
memcpy(*ptr, (char*)forMarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
*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, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
@@ -4617,13 +5521,19 @@
void reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderFloat16, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInt8, sizeof(VkBool32));
@@ -4632,13 +5542,19 @@
void reservedmarshal_VkPhysicalDeviceFloatControlsProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFloatControlsProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkShaderFloatControlsIndependence);
memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence, sizeof(VkShaderFloatControlsIndependence));
@@ -4677,13 +5593,19 @@
void reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -4700,13 +5622,19 @@
void reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
@@ -4751,13 +5679,19 @@
void reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
@@ -4808,13 +5742,19 @@
void reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -4823,26 +5763,38 @@
void reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkSubpassDescriptionDepthStencilResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDescriptionDepthStencilResolve* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkResolveModeFlagBits);
memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->stencilResolveMode, sizeof(VkResolveModeFlagBits));
@@ -4854,19 +5806,25 @@
*ptr += 8;
if (forMarshaling->pDepthStencilResolveAttachment)
{
- reservedmarshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment), ptr);
+ reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment), ptr);
}
}
void reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkResolveModeFlags);
memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes, sizeof(VkResolveModeFlags));
@@ -4879,52 +5837,76 @@
void reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->scalarBlockLayout, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkImageStencilUsageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageStencilUsageCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->stencilUsage, sizeof(VkImageUsageFlags));
*ptr += sizeof(VkImageUsageFlags);
}
void reservedmarshal_VkSamplerReductionModeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerReductionModeCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSamplerReductionMode);
}
void reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
@@ -4933,13 +5915,19 @@
void reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModel, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
@@ -4950,26 +5938,38 @@
void reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->imagelessFramebuffer, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkFramebufferAttachmentImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferAttachmentImageInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
*ptr += sizeof(VkImageCreateFlags);
memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
@@ -4988,30 +5988,42 @@
void reservedmarshal_VkFramebufferAttachmentsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferAttachmentsCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos + i), ptr);
+ reservedmarshal_VkFramebufferAttachmentImageInfo(vkStream, rootType, (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos + i), ptr);
}
}
void reservedmarshal_VkRenderPassAttachmentBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassAttachmentBeginInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
@@ -5031,65 +6043,95 @@
void reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->uniformBufferStandardLayout, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupExtendedTypes, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->separateDepthStencilLayouts, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkAttachmentReferenceStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentReferenceStencilLayout* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageLayout*)&forMarshaling->stencilLayout, sizeof(VkImageLayout));
*ptr += sizeof(VkImageLayout);
}
void reservedmarshal_VkAttachmentDescriptionStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentDescriptionStencilLayout* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageLayout*)&forMarshaling->stencilInitialLayout, sizeof(VkImageLayout));
*ptr += sizeof(VkImageLayout);
memcpy(*ptr, (VkImageLayout*)&forMarshaling->stencilFinalLayout, sizeof(VkImageLayout));
@@ -5098,52 +6140,76 @@
void reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->hostQueryReset, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->timelineSemaphore, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkSemaphoreType*)&forMarshaling->semaphoreType, sizeof(VkSemaphoreType));
*ptr += sizeof(VkSemaphoreType);
memcpy(*ptr, (uint64_t*)&forMarshaling->initialValue, sizeof(uint64_t));
@@ -5152,13 +6218,19 @@
void reservedmarshal_VkTimelineSemaphoreSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTimelineSemaphoreSubmitInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreValueCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -5187,13 +6259,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkSemaphoreWaitFlags*)&forMarshaling->flags, sizeof(VkSemaphoreWaitFlags));
*ptr += sizeof(VkSemaphoreWaitFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->semaphoreCount, sizeof(uint32_t));
@@ -5217,13 +6295,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSemaphore((*&forMarshaling->semaphore));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5234,13 +6318,19 @@
void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->bufferDeviceAddress, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
@@ -5251,13 +6341,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkBuffer((*&forMarshaling->buffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5266,39 +6362,57 @@
void reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->opaqueCaptureAddress, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
void reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->opaqueCaptureAddress, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
void reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5309,17 +6423,19 @@
#ifdef VK_KHR_surface
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, (VkExtent2D*)(&forMarshaling->currentExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minImageExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, (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));
@@ -5334,10 +6450,12 @@
void reservedmarshal_VkSurfaceFormatKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFormatKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
memcpy(*ptr, (VkColorSpaceKHR*)&forMarshaling->colorSpace, sizeof(VkColorSpaceKHR));
@@ -5348,13 +6466,19 @@
#ifdef VK_KHR_swapchain
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSwapchainCreateFlagsKHR);
uint64_t cgen_var_0;
@@ -5367,7 +6491,7 @@
*ptr += sizeof(VkFormat);
memcpy(*ptr, (VkColorSpaceKHR*)&forMarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
*ptr += sizeof(VkColorSpaceKHR);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->imageExtent), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->imageArrayLayers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
@@ -5402,13 +6526,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
@@ -5455,13 +6585,19 @@
void reservedmarshal_VkImageSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSwapchainCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSwapchainKHR((*&forMarshaling->swapchain));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5470,13 +6606,19 @@
void reservedmarshal_VkBindImageMemorySwapchainInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemorySwapchainInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSwapchainKHR((*&forMarshaling->swapchain));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5487,13 +6629,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSwapchainKHR((*&forMarshaling->swapchain));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5514,13 +6662,19 @@
void reservedmarshal_VkDeviceGroupPresentCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t);
memcpy(*ptr, (VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
@@ -5529,13 +6683,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -5546,13 +6706,19 @@
void reservedmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
@@ -5561,66 +6727,80 @@
#ifdef VK_KHR_display
void reservedmarshal_VkDisplayModeParametersKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayModeParametersKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->visibleRegion), ptr);
+ (void)rootType;
+ 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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDisplayModeCreateFlagsKHR);
- reservedmarshal_VkDisplayModeParametersKHR(vkStream, (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)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, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha, sizeof(VkDisplayPlaneAlphaFlagsKHR));
*ptr += sizeof(VkDisplayPlaneAlphaFlagsKHR);
- reservedmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->minSrcPosition), ptr);
- reservedmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->maxSrcPosition), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minSrcExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSrcExtent), ptr);
- reservedmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->minDstPosition), ptr);
- reservedmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->maxDstPosition), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minDstExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, (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)vkStream;
+ (void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDisplayKHR((*&forMarshaling->currentDisplay));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5631,10 +6811,12 @@
void reservedmarshal_VkDisplayPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDisplayKHR((*&forMarshaling->display));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5647,8 +6829,8 @@
memcpy(*ptr, (char*)forMarshaling->displayName, l);
*ptr += l;
}
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalDimensions), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalResolution), ptr);
+ 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));
@@ -5659,13 +6841,19 @@
void reservedmarshal_VkDisplaySurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplaySurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDisplaySurfaceCreateFlagsKHR);
uint64_t cgen_var_0;
@@ -5682,22 +6870,28 @@
*ptr += sizeof(float);
memcpy(*ptr, (VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
*ptr += sizeof(VkDisplayPlaneAlphaFlagBitsKHR);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->imageExtent), ptr);
+ 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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->srcRect), ptr);
- reservedmarshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->dstRect), ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->srcRect), ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->dstRect), ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->persistent, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -5706,13 +6900,19 @@
#ifdef VK_KHR_xlib_surface
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkXlibSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
@@ -5733,13 +6933,19 @@
#ifdef VK_KHR_xcb_surface
void reservedmarshal_VkXcbSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXcbSurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkXcbSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
*ptr += sizeof(VkXcbSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
@@ -5760,13 +6966,19 @@
#ifdef VK_KHR_wayland_surface
void reservedmarshal_VkWaylandSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWaylandSurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkWaylandSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
@@ -5795,13 +7007,19 @@
#ifdef VK_KHR_android_surface
void reservedmarshal_VkAndroidSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidSurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkAndroidSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
@@ -5820,13 +7038,19 @@
#ifdef VK_KHR_win32_surface
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkWin32SurfaceCreateFlagsKHR);
memcpy(*ptr, (HINSTANCE*)&forMarshaling->hinstance, sizeof(HINSTANCE));
@@ -5857,13 +7081,19 @@
#ifdef VK_KHR_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
@@ -5874,13 +7104,19 @@
void reservedmarshal_VkExportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
memcpy((*ptr), &cgen_var_0, 8);
@@ -5899,26 +7135,38 @@
void reservedmarshal_VkMemoryWin32HandlePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryWin32HandlePropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkMemoryGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5931,13 +7179,19 @@
#ifdef VK_KHR_external_memory_fd
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*ptr, (int*)&forMarshaling->fd, sizeof(int));
@@ -5946,26 +7200,38 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5978,13 +7244,19 @@
#ifdef VK_KHR_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
@@ -6031,13 +7303,19 @@
#ifdef VK_KHR_external_semaphore_win32
void reservedmarshal_VkImportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSemaphore((*&forMarshaling->semaphore));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6054,13 +7332,19 @@
void reservedmarshal_VkExportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
memcpy((*ptr), &cgen_var_0, 8);
@@ -6079,13 +7363,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -6114,13 +7404,19 @@
void reservedmarshal_VkSemaphoreGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSemaphore((*&forMarshaling->semaphore));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6133,13 +7429,19 @@
#ifdef VK_KHR_external_semaphore_fd
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSemaphore((*&forMarshaling->semaphore));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6154,13 +7456,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSemaphore((*&forMarshaling->semaphore));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6173,13 +7481,19 @@
#ifdef VK_KHR_push_descriptor
void reservedmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
@@ -6192,22 +7506,26 @@
#ifdef VK_KHR_incremental_present
void reservedmarshal_VkRectLayerKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRectLayerKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->offset), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->extent), ptr);
+ (void)rootType;
+ reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->extent), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->layer, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
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));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -6219,20 +7537,26 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
{
- reservedmarshal_VkRectLayerKHR(vkStream, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i), ptr);
+ reservedmarshal_VkRectLayerKHR(vkStream, rootType, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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);
// WARNING PTR CHECK
@@ -6244,7 +7568,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
{
- reservedmarshal_VkPresentRegionKHR(vkStream, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i), ptr);
+ reservedmarshal_VkPresentRegionKHR(vkStream, rootType, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i), ptr);
}
}
}
@@ -6259,13 +7583,19 @@
#ifdef VK_KHR_shared_presentable_image
void reservedmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkImageUsageFlags);
}
@@ -6278,13 +7608,19 @@
#ifdef VK_KHR_external_fence_win32
void reservedmarshal_VkImportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportFenceWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkFence((*&forMarshaling->fence));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6301,13 +7637,19 @@
void reservedmarshal_VkExportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportFenceWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
memcpy((*ptr), &cgen_var_0, 8);
@@ -6326,13 +7668,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkFence((*&forMarshaling->fence));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6345,13 +7693,19 @@
#ifdef VK_KHR_external_fence_fd
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkFence((*&forMarshaling->fence));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6366,13 +7720,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkFence((*&forMarshaling->fence));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6385,13 +7745,19 @@
#ifdef VK_KHR_performance_query
void reservedmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->performanceCounterQueryPools, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->performanceCounterMultipleQueryPools, sizeof(VkBool32));
@@ -6400,26 +7766,38 @@
void reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->allowCommandBufferQueryCopies, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPerformanceCounterUnitKHR);
memcpy(*ptr, (VkPerformanceCounterScopeKHR*)&forMarshaling->scope, sizeof(VkPerformanceCounterScopeKHR));
@@ -6432,13 +7810,19 @@
void reservedmarshal_VkPerformanceCounterDescriptionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceCounterDescriptionKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPerformanceCounterDescriptionFlagsKHR);
memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
@@ -6451,13 +7835,19 @@
void reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (uint32_t*)&forMarshaling->counterIndexCount, sizeof(uint32_t));
@@ -6468,23 +7858,31 @@
void reservedmarshal_VkPerformanceCounterResultKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceCounterResultKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (int32_t*)&forMarshaling->int32, sizeof(int32_t));
*ptr += sizeof(int32_t);
}
void reservedmarshal_VkAcquireProfilingLockInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAcquireProfilingLockInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkAcquireProfilingLockFlagsKHR);
memcpy(*ptr, (uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
@@ -6493,13 +7891,19 @@
void reservedmarshal_VkPerformanceQuerySubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceQuerySubmitInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->counterPassIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
@@ -6510,13 +7914,19 @@
#ifdef VK_KHR_get_surface_capabilities2
void reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkSurfaceKHR((*&forMarshaling->surface));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6525,26 +7935,38 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat), ptr);
+ 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);
}
#endif
@@ -6553,49 +7975,73 @@
#ifdef VK_KHR_get_display_properties2
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties), ptr);
+ 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);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDisplayModeKHR((*&forMarshaling->mode));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6606,14 +8052,20 @@
void reservedmarshal_VkDisplayPlaneCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilities2KHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities), ptr);
+ 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);
}
#endif
@@ -6634,13 +8086,19 @@
#ifdef VK_KHR_portability_subset
void reservedmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->constantAlphaColorBlendFactors, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->events, sizeof(VkBool32));
@@ -6675,13 +8133,19 @@
void reservedmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->minVertexInputBindingStrideAlignment, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
@@ -6700,13 +8164,19 @@
#ifdef VK_KHR_shader_clock
void reservedmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupClock, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDeviceClock, sizeof(VkBool32));
@@ -6729,13 +8199,19 @@
#ifdef VK_KHR_shader_terminate_invocation
void reservedmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderTerminateInvocation, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -6744,40 +8220,58 @@
#ifdef VK_KHR_fragment_shading_rate
void reservedmarshal_VkFragmentShadingRateAttachmentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkAttachmentReference2(vkStream, (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
}
void reservedmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->fragmentSize), ptr);
+ 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));
*ptr += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
}
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineFragmentShadingRate, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveFragmentShadingRate, sizeof(VkBool32));
@@ -6788,15 +8282,21 @@
void reservedmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minFragmentShadingRateAttachmentTexelSize), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxFragmentShadingRateAttachmentTexelSize), ptr);
+ 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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveFragmentShadingRateWithMultipleViewports, sizeof(VkBool32));
@@ -6805,7 +8305,7 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateNonTrivialCombinerOps, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- reservedmarshal_VkExtent2D(vkStream, (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));
@@ -6830,16 +8330,22 @@
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (VkExtent2D*)(&forMarshaling->fragmentSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize), ptr);
}
#endif
@@ -6848,13 +8354,19 @@
#ifdef VK_KHR_surface_protected_capabilities
void reservedmarshal_VkSurfaceProtectedCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceProtectedCapabilitiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->supportsProtected, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -6871,26 +8383,38 @@
#ifdef VK_KHR_pipeline_executable_properties
void reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineExecutableInfo, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkPipeline((*&forMarshaling->pipeline));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6899,13 +8423,19 @@
void reservedmarshal_VkPipelineExecutablePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutablePropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stages, sizeof(VkShaderStageFlags));
*ptr += sizeof(VkShaderStageFlags);
memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
@@ -6918,13 +8448,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkPipeline((*&forMarshaling->pipeline));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6935,41 +8471,55 @@
void reservedmarshal_VkPipelineExecutableStatisticValueKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticValueKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkBool32*)&forMarshaling->b32, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPipelineExecutableStatisticKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
*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));
*ptr += sizeof(VkPipelineExecutableStatisticFormatKHR);
- reservedmarshal_VkPipelineExecutableStatisticValueKHR(vkStream, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
*ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
memcpy(*ptr, (char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
@@ -6996,13 +8546,19 @@
#ifdef VK_KHR_pipeline_library
void reservedmarshal_VkPipelineLibraryCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineLibraryCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
@@ -7026,13 +8582,19 @@
#ifdef VK_KHR_copy_commands2
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
@@ -7043,13 +8605,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkBuffer((*&forMarshaling->srcBuffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7062,35 +8630,47 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- reservedmarshal_VkBufferCopy2KHR(vkStream, (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i), ptr);
+ reservedmarshal_VkBufferCopy2KHR(vkStream, rootType, (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent), ptr);
+ 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_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), 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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->srcImage));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7107,39 +8687,51 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- reservedmarshal_VkImageCopy2KHR(vkStream, (const VkImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
+ reservedmarshal_VkImageCopy2KHR(vkStream, rootType, (const VkImageCopy2KHR*)(forMarshaling->pRegions + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->imageExtent), 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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkBuffer((*&forMarshaling->srcBuffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7154,19 +8746,25 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- reservedmarshal_VkBufferImageCopy2KHR(vkStream, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
+ reservedmarshal_VkBufferImageCopy2KHR(vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->srcImage));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7181,40 +8779,52 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- reservedmarshal_VkBufferImageCopy2KHR(vkStream, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
+ reservedmarshal_VkBufferImageCopy2KHR(vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), 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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
{
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->srcOffsets + i), ptr);
+ rootType = forMarshaling->sType;
}
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
+ 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, (VkOffset3D*)(forMarshaling->dstOffsets + i), ptr);
+ 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);
}
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->srcImage));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7231,7 +8841,7 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- reservedmarshal_VkImageBlit2KHR(vkStream, (const VkImageBlit2KHR*)(forMarshaling->pRegions + i), ptr);
+ reservedmarshal_VkImageBlit2KHR(vkStream, rootType, (const VkImageBlit2KHR*)(forMarshaling->pRegions + i), ptr);
}
memcpy(*ptr, (VkFilter*)&forMarshaling->filter, sizeof(VkFilter));
*ptr += sizeof(VkFilter);
@@ -7239,29 +8849,41 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
- reservedmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent), ptr);
+ 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_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), 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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->srcImage));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7278,7 +8900,7 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
{
- reservedmarshal_VkImageResolve2KHR(vkStream, (const VkImageResolve2KHR*)(forMarshaling->pRegions + i), ptr);
+ reservedmarshal_VkImageResolve2KHR(vkStream, rootType, (const VkImageResolve2KHR*)(forMarshaling->pRegions + i), ptr);
}
}
@@ -7286,13 +8908,19 @@
#ifdef VK_ANDROID_native_buffer
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->handle;
memcpy((*ptr), &cgen_var_0, 8);
@@ -7319,13 +8947,19 @@
#ifdef VK_EXT_debug_report
void reservedmarshal_VkDebugReportCallbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugReportCallbackCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
*ptr += sizeof(VkDebugReportFlagsEXT);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnCallback;
@@ -7354,13 +8988,19 @@
#ifdef VK_AMD_rasterization_order
void reservedmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkRasterizationOrderAMD);
}
@@ -7373,13 +9013,19 @@
#ifdef VK_EXT_debug_marker
void reservedmarshal_VkDebugMarkerObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerObjectNameInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDebugReportObjectTypeEXT);
memcpy(*ptr, (uint64_t*)&forMarshaling->object, sizeof(uint64_t));
@@ -7396,13 +9042,19 @@
void reservedmarshal_VkDebugMarkerObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerObjectTagInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDebugReportObjectTypeEXT);
memcpy(*ptr, (uint64_t*)&forMarshaling->object, sizeof(uint64_t));
@@ -7419,13 +9071,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
@@ -7444,39 +9102,57 @@
#ifdef VK_NV_dedicated_allocation
void reservedmarshal_VkDedicatedAllocationImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationImageCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7491,13 +9167,19 @@
#ifdef VK_EXT_transform_feedback
void reservedmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedback, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->geometryStreams, sizeof(VkBool32));
@@ -7506,13 +9188,19 @@
void reservedmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackStreams, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackBuffers, sizeof(uint32_t));
@@ -7537,13 +9225,19 @@
void reservedmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT);
memcpy(*ptr, (uint32_t*)&forMarshaling->rasterizationStream, sizeof(uint32_t));
@@ -7554,13 +9248,19 @@
#ifdef VK_NVX_image_view_handle
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkImageView((*&forMarshaling->imageView));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7575,13 +9275,19 @@
void reservedmarshal_VkImageViewAddressPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageViewAddressPropertiesNVX* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
*ptr += sizeof(VkDeviceAddress);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
@@ -7600,13 +9306,19 @@
#ifdef VK_AMD_texture_gather_bias_lod
void reservedmarshal_VkTextureLODGatherFormatPropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -7615,10 +9327,12 @@
#ifdef VK_AMD_shader_info
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->numUsedSgprs, sizeof(uint32_t));
@@ -7637,13 +9351,15 @@
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, (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));
@@ -7662,13 +9378,19 @@
#ifdef VK_GGP_stream_descriptor_surface
void reservedmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP);
memcpy(*ptr, (GgpStreamDescriptor*)&forMarshaling->streamDescriptor, sizeof(GgpStreamDescriptor));
@@ -7679,13 +9401,19 @@
#ifdef VK_NV_corner_sampled_image
void reservedmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->cornerSampledImage, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -7696,11 +9424,13 @@
#ifdef VK_NV_external_memory_capabilities
void reservedmarshal_VkExternalImageFormatPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalImageFormatPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties), ptr);
+ (void)rootType;
+ 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));
@@ -7713,26 +9443,38 @@
#ifdef VK_NV_external_memory
void reservedmarshal_VkExternalMemoryImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}
@@ -7741,13 +9483,19 @@
#ifdef VK_NV_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
@@ -7756,13 +9504,19 @@
void reservedmarshal_VkExportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
memcpy((*ptr), &cgen_var_0, 8);
@@ -7781,13 +9535,19 @@
#ifdef VK_NV_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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)
@@ -7830,13 +9590,19 @@
#ifdef VK_EXT_validation_flags
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -7847,13 +9613,19 @@
#ifdef VK_NN_vi_surface
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkViSurfaceCreateFlagsNN);
// WARNING PTR CHECK
@@ -7876,13 +9648,19 @@
#ifdef VK_EXT_texture_compression_astc_hdr
void reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -7891,26 +9669,38 @@
#ifdef VK_EXT_astc_decode_mode
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkFormat*)&forMarshaling->decodeMode, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
}
void reservedmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->decodeModeSharedExponent, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -7919,13 +9709,19 @@
#ifdef VK_EXT_conditional_rendering
void reservedmarshal_VkConditionalRenderingBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkConditionalRenderingBeginInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkBuffer((*&forMarshaling->buffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7938,13 +9734,19 @@
void reservedmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->conditionalRendering, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->inheritedConditionalRendering, sizeof(VkBool32));
@@ -7953,13 +9755,19 @@
void reservedmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->conditionalRenderingEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -7968,10 +9776,12 @@
#ifdef VK_NV_clip_space_w_scaling
void reservedmarshal_VkViewportWScalingNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkViewportWScalingNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (float*)&forMarshaling->xcoeff, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->ycoeff, sizeof(float));
@@ -7980,13 +9790,19 @@
void reservedmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
@@ -8000,7 +9816,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
{
- reservedmarshal_VkViewportWScalingNV(vkStream, (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i), ptr);
+ reservedmarshal_VkViewportWScalingNV(vkStream, rootType, (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i), ptr);
}
}
}
@@ -8013,20 +9829,26 @@
#ifdef VK_EXT_display_surface_counter
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
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, (VkExtent2D*)(&forMarshaling->currentExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->minImageExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, (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));
@@ -8045,52 +9867,76 @@
#ifdef VK_EXT_display_control
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDisplayPowerStateEXT);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
*ptr += sizeof(VkDeviceEventTypeEXT);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDisplayEventTypeEXT);
}
void reservedmarshal_VkSwapchainCounterCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainCounterCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSurfaceCounterFlagsEXT);
}
@@ -8099,20 +9945,24 @@
#ifdef VK_GOOGLE_display_timing
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));
*ptr += sizeof(uint64_t);
}
void reservedmarshal_VkPastPresentationTimingGOOGLE(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPastPresentationTimingGOOGLE* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
@@ -8127,10 +9977,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
@@ -8139,13 +9991,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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);
// WARNING PTR CHECK
@@ -8157,7 +10015,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
{
- reservedmarshal_VkPresentTimeGOOGLE(vkStream, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i), ptr);
+ reservedmarshal_VkPresentTimeGOOGLE(vkStream, rootType, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i), ptr);
}
}
}
@@ -8172,13 +10030,19 @@
#ifdef VK_NVX_multiview_per_view_attributes
void reservedmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->perViewPositionAllComponents, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -8187,10 +10051,12 @@
#ifdef VK_NV_viewport_swizzle
void reservedmarshal_VkViewportSwizzleNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkViewportSwizzleNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->x, sizeof(VkViewportCoordinateSwizzleNV));
*ptr += sizeof(VkViewportCoordinateSwizzleNV);
memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->y, sizeof(VkViewportCoordinateSwizzleNV));
@@ -8203,13 +10069,19 @@
void reservedmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
@@ -8223,7 +10095,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
{
- reservedmarshal_VkViewportSwizzleNV(vkStream, (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i), ptr);
+ reservedmarshal_VkViewportSwizzleNV(vkStream, rootType, (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i), ptr);
}
}
}
@@ -8232,26 +10104,38 @@
#ifdef VK_EXT_discard_rectangles
void reservedmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxDiscardRectangles, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT);
memcpy(*ptr, (VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
@@ -8267,7 +10151,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
{
- reservedmarshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pDiscardRectangles + i), ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pDiscardRectangles + i), ptr);
}
}
}
@@ -8276,13 +10160,19 @@
#ifdef VK_EXT_conservative_rasterization
void reservedmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (float*)&forMarshaling->primitiveOverestimationSize, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
@@ -8305,13 +10195,19 @@
void reservedmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT);
memcpy(*ptr, (VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode, sizeof(VkConservativeRasterizationModeEXT));
@@ -8324,26 +10220,38 @@
#ifdef VK_EXT_depth_clip_enable
void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
@@ -8356,10 +10264,12 @@
#ifdef VK_EXT_hdr_metadata
void reservedmarshal_VkXYColorEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXYColorEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (float*)&forMarshaling->x, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->y, sizeof(float));
@@ -8368,17 +10278,23 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed), ptr);
- reservedmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen), ptr);
- reservedmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue), ptr);
- reservedmarshal_VkXYColorEXT(vkStream, (VkXYColorEXT*)(&forMarshaling->whitePoint), ptr);
+ 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);
memcpy(*ptr, (float*)&forMarshaling->maxLuminance, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->minLuminance, sizeof(float));
@@ -8393,13 +10309,19 @@
#ifdef VK_MVK_ios_surface
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkIOSSurfaceCreateFlagsMVK);
// WARNING PTR CHECK
@@ -8418,13 +10340,19 @@
#ifdef VK_MVK_macos_surface
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkMacOSSurfaceCreateFlagsMVK);
// WARNING PTR CHECK
@@ -8449,13 +10377,19 @@
#ifdef VK_EXT_debug_utils
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
@@ -8470,13 +10404,19 @@
void reservedmarshal_VkDebugUtilsObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsObjectNameInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
*ptr += sizeof(VkObjectType);
memcpy(*ptr, (uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
@@ -8515,13 +10455,19 @@
void reservedmarshal_VkDebugUtilsMessengerCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT);
if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
@@ -8575,7 +10521,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
{
- reservedmarshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i), ptr);
+ reservedmarshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i), ptr);
}
}
memcpy(*ptr, (uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
@@ -8589,7 +10535,7 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
{
- reservedmarshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i), ptr);
+ reservedmarshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i), ptr);
}
}
memcpy(*ptr, (uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
@@ -8603,20 +10549,26 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
{
- reservedmarshal_VkDebugUtilsObjectNameInfoEXT(vkStream, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i), ptr);
+ reservedmarshal_VkDebugUtilsObjectNameInfoEXT(vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i), ptr);
}
}
}
void reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDebugUtilsMessengerCreateFlagsEXT);
memcpy(*ptr, (VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
@@ -8641,13 +10593,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
*ptr += sizeof(VkObjectType);
memcpy(*ptr, (uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
@@ -8666,26 +10624,38 @@
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void reservedmarshal_VkAndroidHardwareBufferUsageANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferUsageANDROID* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
void reservedmarshal_VkAndroidHardwareBufferPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
@@ -8694,20 +10664,26 @@
void reservedmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
- reservedmarshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents), 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));
@@ -8720,26 +10696,38 @@
void reservedmarshal_VkImportAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (AHardwareBuffer*)forMarshaling->buffer, sizeof(AHardwareBuffer));
*ptr += sizeof(AHardwareBuffer);
}
void reservedmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8748,13 +10736,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
@@ -8771,13 +10765,19 @@
#ifdef VK_EXT_inline_uniform_block
void reservedmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -8786,13 +10786,19 @@
void reservedmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -8807,13 +10813,19 @@
void reservedmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -8822,13 +10834,19 @@
void reservedmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
@@ -8839,10 +10857,12 @@
#ifdef VK_EXT_sample_locations
void reservedmarshal_VkSampleLocationEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSampleLocationEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (float*)&forMarshaling->x, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->y, sizeof(float));
@@ -8851,95 +10871,123 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSampleCountFlagBits);
- reservedmarshal_VkExtent2D(vkStream, (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, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i), ptr);
+ reservedmarshal_VkSampleLocationEXT(vkStream, rootType, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i), ptr);
}
}
void reservedmarshal_VkAttachmentSampleLocationsEXT(
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, (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)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->subpassIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkSampleLocationsInfoEXT(vkStream, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentInitialSampleLocationsCount; ++i)
{
- reservedmarshal_VkAttachmentSampleLocationsEXT(vkStream, (const VkAttachmentSampleLocationsEXT*)(forMarshaling->pAttachmentInitialSampleLocations + i), ptr);
+ 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, (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i), ptr);
+ reservedmarshal_VkSubpassSampleLocationsEXT(vkStream, rootType, (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i), ptr);
}
}
void reservedmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSampleCountFlags);
- reservedmarshal_VkExtent2D(vkStream, (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));
@@ -8950,40 +10998,58 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize), ptr);
+ 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);
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkBool32*)&forMarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
@@ -9000,13 +11066,19 @@
void reservedmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->srcPremultiplied, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->dstPremultiplied, sizeof(VkBool32));
@@ -9019,13 +11091,19 @@
#ifdef VK_NV_fragment_coverage_to_color
void reservedmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineCoverageToColorStateCreateFlagsNV);
memcpy(*ptr, (VkBool32*)&forMarshaling->coverageToColorEnable, sizeof(VkBool32));
@@ -9038,13 +11116,19 @@
#ifdef VK_NV_framebuffer_mixed_samples
void reservedmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineCoverageModulationStateCreateFlagsNV);
memcpy(*ptr, (VkCoverageModulationModeNV*)&forMarshaling->coverageModulationMode, sizeof(VkCoverageModulationModeNV));
@@ -9071,13 +11155,19 @@
#ifdef VK_NV_shader_sm_builtins
void reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->shaderSMCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->shaderWarpsPerSM, sizeof(uint32_t));
@@ -9086,13 +11176,19 @@
void reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSMBuiltins, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -9103,10 +11199,12 @@
#ifdef VK_EXT_image_drm_format_modifier
void reservedmarshal_VkDrmFormatModifierPropertiesEXT(
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));
@@ -9117,13 +11215,19 @@
void reservedmarshal_VkDrmFormatModifierPropertiesListEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesListEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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);
// WARNING PTR CHECK
@@ -9135,20 +11239,26 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i)
{
- reservedmarshal_VkDrmFormatModifierPropertiesEXT(vkStream, (VkDrmFormatModifierPropertiesEXT*)(forMarshaling->pDrmFormatModifierProperties + i), ptr);
+ reservedmarshal_VkDrmFormatModifierPropertiesEXT(vkStream, rootType, (VkDrmFormatModifierPropertiesEXT*)(forMarshaling->pDrmFormatModifierProperties + i), ptr);
}
}
}
void reservedmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
memcpy(*ptr, (VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
@@ -9169,13 +11279,19 @@
void reservedmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -9184,32 +11300,44 @@
void reservedmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
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);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierPlaneCount; ++i)
{
- reservedmarshal_VkSubresourceLayout(vkStream, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i), ptr);
+ reservedmarshal_VkSubresourceLayout(vkStream, rootType, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i), ptr);
}
}
void reservedmarshal_VkImageDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
@@ -9218,13 +11346,19 @@
#ifdef VK_EXT_validation_cache
void reservedmarshal_VkValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationCacheCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkValidationCacheCreateFlagsEXT);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
@@ -9237,13 +11371,19 @@
void reservedmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkValidationCacheEXT((*&forMarshaling->validationCache));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9258,10 +11398,12 @@
#ifdef VK_NV_shading_rate_image
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));
@@ -9270,13 +11412,19 @@
void reservedmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shadingRateImageEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
@@ -9290,20 +11438,26 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
{
- reservedmarshal_VkShadingRatePaletteNV(vkStream, (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i), ptr);
+ reservedmarshal_VkShadingRatePaletteNV(vkStream, rootType, (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i), ptr);
}
}
}
void reservedmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shadingRateImage, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shadingRateCoarseSampleOrder, sizeof(VkBool32));
@@ -9312,14 +11466,20 @@
void reservedmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->shadingRateTexelSize), ptr);
+ 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);
memcpy(*ptr, (uint32_t*)&forMarshaling->shadingRatePaletteSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->shadingRateMaxCoarseSamples, sizeof(uint32_t));
@@ -9328,10 +11488,12 @@
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));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->pixelY, sizeof(uint32_t));
@@ -9342,10 +11504,12 @@
void reservedmarshal_VkCoarseSampleOrderCustomNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCoarseSampleOrderCustomNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkShadingRatePaletteEntryNV*)&forMarshaling->shadingRate, sizeof(VkShadingRatePaletteEntryNV));
*ptr += sizeof(VkShadingRatePaletteEntryNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->sampleCount, sizeof(uint32_t));
@@ -9354,26 +11518,32 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationCount; ++i)
{
- reservedmarshal_VkCoarseSampleLocationNV(vkStream, (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i), ptr);
+ reservedmarshal_VkCoarseSampleLocationNV(vkStream, rootType, (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i), ptr);
}
}
void reservedmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*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, (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i), ptr);
+ reservedmarshal_VkCoarseSampleOrderCustomNV(vkStream, rootType, (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i), ptr);
}
}
@@ -9381,13 +11551,19 @@
#ifdef VK_NV_ray_tracing
void reservedmarshal_VkRayTracingShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkRayTracingShaderGroupTypeKHR);
memcpy(*ptr, (uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
@@ -9402,26 +11578,32 @@
void reservedmarshal_VkRayTracingPipelineCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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);
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, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
+ 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, (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i), ptr);
+ reservedmarshal_VkRayTracingShaderGroupCreateInfoNV(vkStream, rootType, (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->maxRecursionDepth, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -9439,13 +11621,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkBuffer((*&forMarshaling->vertexData));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9478,13 +11666,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkBuffer((*&forMarshaling->aabbData));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9499,39 +11693,53 @@
void reservedmarshal_VkGeometryDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryDataNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
- reservedmarshal_VkGeometryTrianglesNV(vkStream, (VkGeometryTrianglesNV*)(&forMarshaling->triangles), ptr);
- reservedmarshal_VkGeometryAABBNV(vkStream, (VkGeometryAABBNV*)(&forMarshaling->aabbs), ptr);
+ (void)rootType;
+ 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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkAccelerationStructureTypeNV);
memcpy(*ptr, (VkBuildAccelerationStructureFlagsNV*)&forMarshaling->flags, sizeof(VkBuildAccelerationStructureFlagsNV));
@@ -9542,33 +11750,45 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i)
{
- reservedmarshal_VkGeometryNV(vkStream, (const VkGeometryNV*)(forMarshaling->pGeometries + i), ptr);
+ reservedmarshal_VkGeometryNV(vkStream, rootType, (const VkGeometryNV*)(forMarshaling->pGeometries + i), ptr);
}
}
void reservedmarshal_VkAccelerationStructureCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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_VkAccelerationStructureNV((*&forMarshaling->accelerationStructure));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9587,13 +11807,19 @@
void reservedmarshal_VkWriteDescriptorSetAccelerationStructureNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->accelerationStructureCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -9621,13 +11847,19 @@
void reservedmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkAccelerationStructureMemoryRequirementsTypeNV);
uint64_t cgen_var_0;
@@ -9638,13 +11870,19 @@
void reservedmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->shaderGroupHandleSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxRecursionDepth, sizeof(uint32_t));
@@ -9665,20 +11903,24 @@
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);
}
void reservedmarshal_VkAabbPositionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAabbPositionsKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (float*)&forMarshaling->minX, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->minY, sizeof(float));
@@ -9695,6 +11937,7 @@
void reservedmarshal_VkAccelerationStructureInstanceKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureInstanceKHR* forMarshaling,
uint8_t** ptr)
{
@@ -9707,7 +11950,7 @@
(void)vkStream;
const VkAccelerationStructureInstanceKHRWithoutBitFields* forMarshaling_new = (const VkAccelerationStructureInstanceKHRWithoutBitFields*)(forMarshaling);
- reservedmarshal_VkTransformMatrixKHR(vkStream, (VkTransformMatrixKHR*)(&forMarshaling_new->transform), ptr);
+ 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);
@@ -9721,26 +11964,38 @@
#ifdef VK_NV_representative_fragment_test
void reservedmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->representativeFragmentTest, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->representativeFragmentTestEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -9749,26 +12004,38 @@
#ifdef VK_EXT_filter_cubic
void reservedmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageViewType*)&forMarshaling->imageViewType, sizeof(VkImageViewType));
*ptr += sizeof(VkImageViewType);
}
void reservedmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->filterCubic, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->filterCubicMinmax, sizeof(VkBool32));
@@ -9781,13 +12048,19 @@
#ifdef VK_EXT_global_priority
void reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkQueueGlobalPriorityEXT);
}
@@ -9796,13 +12069,19 @@
#ifdef VK_EXT_external_memory_host
void reservedmarshal_VkImportMemoryHostPointerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryHostPointerInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
// WARNING PTR CHECK
@@ -9819,26 +12098,38 @@
void reservedmarshal_VkMemoryHostPointerPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryHostPointerPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceSize);
}
@@ -9849,13 +12140,19 @@
#ifdef VK_AMD_pipeline_compiler_control
void reservedmarshal_VkPipelineCompilerControlCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineCompilerControlFlagsAMD);
}
@@ -9864,13 +12161,19 @@
#ifdef VK_EXT_calibrated_timestamps
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkTimeDomainEXT*)&forMarshaling->timeDomain, sizeof(VkTimeDomainEXT));
*ptr += sizeof(VkTimeDomainEXT);
}
@@ -9879,13 +12182,19 @@
#ifdef VK_AMD_shader_core_properties
void reservedmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->shaderEngineCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->shaderArraysPerEngineCount, sizeof(uint32_t));
@@ -9920,13 +12229,19 @@
#ifdef VK_AMD_memory_overallocation_behavior
void reservedmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkMemoryOverallocationBehaviorAMD);
}
@@ -9935,23 +12250,31 @@
#ifdef VK_EXT_vertex_attribute_divisor
void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkVertexInputBindingDivisorDescriptionEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
@@ -9960,30 +12283,42 @@
void reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling->pVertexBindingDivisors + i), ptr);
+ reservedmarshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, rootType, (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling->pVertexBindingDivisors + i), ptr);
}
}
void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -9994,13 +12329,19 @@
#ifdef VK_GGP_frame_token
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (GgpFrameToken*)&forMarshaling->frameToken, sizeof(GgpFrameToken));
*ptr += sizeof(GgpFrameToken);
}
@@ -10009,10 +12350,12 @@
#ifdef VK_EXT_pipeline_creation_feedback
void reservedmarshal_VkPipelineCreationFeedbackEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkPipelineCreationFeedbackFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineCreationFeedbackFlagsEXT));
*ptr += sizeof(VkPipelineCreationFeedbackFlagsEXT);
memcpy(*ptr, (uint64_t*)&forMarshaling->duration, sizeof(uint64_t));
@@ -10021,19 +12364,25 @@
void reservedmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkPipelineCreationFeedbackEXT(vkStream, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineCreationFeedback), ptr);
+ 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);
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, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks + i), ptr);
+ reservedmarshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks + i), ptr);
}
}
@@ -10043,13 +12392,19 @@
#ifdef VK_NV_compute_shader_derivatives
void reservedmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->computeDerivativeGroupQuads, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->computeDerivativeGroupLinear, sizeof(VkBool32));
@@ -10060,13 +12415,19 @@
#ifdef VK_NV_mesh_shader
void reservedmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->taskShader, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->meshShader, sizeof(VkBool32));
@@ -10075,13 +12436,19 @@
void reservedmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxDrawMeshTasksCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
@@ -10112,10 +12479,12 @@
void reservedmarshal_VkDrawMeshTasksIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrawMeshTasksIndirectCommandNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->taskCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->firstTask, sizeof(uint32_t));
@@ -10126,13 +12495,19 @@
#ifdef VK_NV_fragment_shader_barycentric
void reservedmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -10141,13 +12516,19 @@
#ifdef VK_NV_shader_image_footprint
void reservedmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->imageFootprint, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -10156,13 +12537,19 @@
#ifdef VK_NV_scissor_exclusive
void reservedmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->exclusiveScissorCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -10174,20 +12561,26 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->exclusiveScissorCount; ++i)
{
- reservedmarshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pExclusiveScissors + i), ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pExclusiveScissors + i), ptr);
}
}
}
void reservedmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->exclusiveScissor, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -10196,26 +12589,38 @@
#ifdef VK_NV_device_diagnostic_checkpoints
void reservedmarshal_VkQueueFamilyCheckpointPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueueFamilyCheckpointPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineStageFlags);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
*ptr += sizeof(VkPipelineStageFlagBits);
// WARNING PTR CHECK
@@ -10234,13 +12639,19 @@
#ifdef VK_INTEL_shader_integer_functions2
void reservedmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderIntegerFunctions2, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -10249,34 +12660,44 @@
#ifdef VK_INTEL_performance_query
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)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkPerformanceValueTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceValueTypeINTEL));
*ptr += sizeof(VkPerformanceValueTypeINTEL);
- reservedmarshal_VkPerformanceValueDataINTEL(vkStream, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
memcpy((*ptr), &cgen_var_0, 8);
@@ -10291,52 +12712,76 @@
void reservedmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkQueryPoolSamplingModeINTEL);
}
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->marker, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
void reservedmarshal_VkPerformanceStreamMarkerInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceStreamMarkerInfoINTEL* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->marker, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkPerformanceOverrideInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceOverrideInfoINTEL* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPerformanceOverrideTypeINTEL);
memcpy(*ptr, (VkBool32*)&forMarshaling->enable, sizeof(VkBool32));
@@ -10347,13 +12792,19 @@
void reservedmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPerformanceConfigurationTypeINTEL);
}
@@ -10362,13 +12813,19 @@
#ifdef VK_EXT_pci_bus_info
void reservedmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->pciDomain, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->pciBus, sizeof(uint32_t));
@@ -10383,26 +12840,38 @@
#ifdef VK_AMD_display_native_hdr
void reservedmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->localDimmingSupport, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->localDimmingEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -10411,13 +12880,19 @@
#ifdef VK_FUCHSIA_imagepipe_surface
void reservedmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA);
memcpy(*ptr, (zx_handle_t*)&forMarshaling->imagePipeHandle, sizeof(zx_handle_t));
@@ -10428,13 +12903,19 @@
#ifdef VK_EXT_metal_surface
void reservedmarshal_VkMetalSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMetalSurfaceCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkMetalSurfaceCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkMetalSurfaceCreateFlagsEXT));
*ptr += sizeof(VkMetalSurfaceCreateFlagsEXT);
// WARNING PTR CHECK
@@ -10450,52 +12931,67 @@
}
#endif
-#ifdef VK_GOOGLE_color_buffer
-void reservedmarshal_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
VulkanStreamGuest* vkStream,
- const VkImportColorBufferGOOGLE* forMarshaling,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->colorBuffer, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityMap, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityMapDynamic, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityMapNonSubsampledImages, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkImportBufferGOOGLE(
+void reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
VulkanStreamGuest* vkStream,
- const VkImportBufferGOOGLE* forMarshaling,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->buffer, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
+ 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);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityInvocations, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkImportPhysicalAddressGOOGLE(
+void reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
VulkanStreamGuest* vkStream,
- const VkImportPhysicalAddressGOOGLE* forMarshaling,
+ VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint64_t*)&forMarshaling->physicalAddress, sizeof(uint64_t));
- *ptr += sizeof(uint64_t);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
- *ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
- *ptr += sizeof(VkFormat);
- memcpy(*ptr, (VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
- *ptr += sizeof(VkImageTiling);
- memcpy(*ptr, (uint32_t*)&forMarshaling->tilingParameter, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
+ 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);
}
#endif
@@ -10508,13 +13004,19 @@
#ifdef VK_EXT_subgroup_size_control
void reservedmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->subgroupSizeControl, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->computeFullSubgroups, sizeof(VkBool32));
@@ -10523,13 +13025,19 @@
void reservedmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->minSubgroupSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxSubgroupSize, sizeof(uint32_t));
@@ -10542,13 +13050,19 @@
void reservedmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->requiredSubgroupSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
@@ -10557,13 +13071,19 @@
#ifdef VK_AMD_shader_core_properties2
void reservedmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkShaderCorePropertiesFlagsAMD);
memcpy(*ptr, (uint32_t*)&forMarshaling->activeComputeUnitCount, sizeof(uint32_t));
@@ -10574,13 +13094,19 @@
#ifdef VK_AMD_device_coherent_memory
void reservedmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->deviceCoherentMemory, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -10589,13 +13115,19 @@
#ifdef VK_EXT_shader_image_atomic_int64
void reservedmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderImageInt64Atomics, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->sparseImageInt64Atomics, sizeof(VkBool32));
@@ -10606,13 +13138,19 @@
#ifdef VK_EXT_memory_budget
void reservedmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)forMarshaling->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
@@ -10623,26 +13161,38 @@
#ifdef VK_EXT_memory_priority
void reservedmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->memoryPriority, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkMemoryPriorityAllocateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryPriorityAllocateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (float*)&forMarshaling->priority, sizeof(float));
*ptr += sizeof(float);
}
@@ -10651,13 +13201,19 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
void reservedmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->dedicatedAllocationImageAliasing, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -10666,13 +13222,19 @@
#ifdef VK_EXT_buffer_device_address
void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->bufferDeviceAddress, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->bufferDeviceAddressCaptureReplay, sizeof(VkBool32));
@@ -10683,13 +13245,19 @@
void reservedmarshal_VkBufferDeviceAddressCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferDeviceAddressCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
*ptr += sizeof(VkDeviceAddress);
}
@@ -10698,13 +13266,19 @@
#ifdef VK_EXT_tooling_info
void reservedmarshal_VkPhysicalDeviceToolPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceToolPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
*ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
memcpy(*ptr, (char*)forMarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
@@ -10723,13 +13297,19 @@
#ifdef VK_EXT_validation_features
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -10744,13 +13324,19 @@
#ifdef VK_NV_cooperative_matrix
void reservedmarshal_VkCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCooperativeMatrixPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->MSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->NSize, sizeof(uint32_t));
@@ -10771,13 +13357,19 @@
void reservedmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->cooperativeMatrix, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->cooperativeMatrixRobustBufferAccess, sizeof(VkBool32));
@@ -10786,13 +13378,19 @@
void reservedmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkShaderStageFlags);
}
@@ -10801,26 +13399,38 @@
#ifdef VK_NV_coverage_reduction_mode
void reservedmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->coverageReductionMode, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineCoverageReductionStateCreateFlagsNV);
memcpy(*ptr, (VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode, sizeof(VkCoverageReductionModeNV));
@@ -10829,13 +13439,19 @@
void reservedmarshal_VkFramebufferMixedSamplesCombinationNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkCoverageReductionModeNV);
memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
@@ -10850,13 +13466,19 @@
#ifdef VK_EXT_fragment_shader_interlock
void reservedmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShaderSampleInterlock, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShaderPixelInterlock, sizeof(VkBool32));
@@ -10869,13 +13491,19 @@
#ifdef VK_EXT_ycbcr_image_arrays
void reservedmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->ycbcrImageArrays, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -10884,39 +13512,57 @@
#ifdef VK_EXT_full_screen_exclusive
void reservedmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkFullScreenExclusiveEXT);
}
void reservedmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->fullScreenExclusiveSupported, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (HMONITOR*)&forMarshaling->hmonitor, sizeof(HMONITOR));
*ptr += sizeof(HMONITOR);
}
@@ -10925,13 +13571,19 @@
#ifdef VK_EXT_headless_surface
void reservedmarshal_VkHeadlessSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkHeadlessSurfaceCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkHeadlessSurfaceCreateFlagsEXT);
}
@@ -10940,13 +13592,19 @@
#ifdef VK_EXT_line_rasterization
void reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
@@ -10963,26 +13621,38 @@
void reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkLineRasterizationModeEXT);
memcpy(*ptr, (VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
@@ -10997,13 +13667,19 @@
#ifdef VK_EXT_shader_atomic_float
void reservedmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderBufferFloat32Atomics, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderBufferFloat32AtomicAdd, sizeof(VkBool32));
@@ -11036,13 +13712,19 @@
#ifdef VK_EXT_index_type_uint8
void reservedmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->indexTypeUint8, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -11051,13 +13733,19 @@
#ifdef VK_EXT_extended_dynamic_state
void reservedmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->extendedDynamicState, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -11066,13 +13754,19 @@
#ifdef VK_EXT_shader_demote_to_helper_invocation
void reservedmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -11081,13 +13775,19 @@
#ifdef VK_NV_device_generated_commands
void reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxGraphicsShaderGroupCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxIndirectSequenceCount, sizeof(uint32_t));
@@ -11110,31 +13810,43 @@
void reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->deviceGeneratedCommands, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkGraphicsShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsShaderGroupCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
+ reservedmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
@@ -11143,7 +13855,7 @@
*ptr += 8;
if (forMarshaling->pVertexInputState)
{
- reservedmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
+ reservedmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
@@ -11152,24 +13864,30 @@
*ptr += 8;
if (forMarshaling->pTessellationState)
{
- reservedmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState), ptr);
+ reservedmarshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState), ptr);
}
}
void reservedmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i), ptr);
+ reservedmarshal_VkGraphicsShaderGroupCreateInfoNV(vkStream, rootType, (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->pipelineCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -11190,20 +13908,24 @@
void reservedmarshal_VkBindShaderGroupIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindShaderGroupIndirectCommandNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->groupIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkBindIndexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindIndexBufferIndirectCommandNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->bufferAddress, sizeof(VkDeviceAddress));
*ptr += sizeof(VkDeviceAddress);
memcpy(*ptr, (uint32_t*)&forMarshaling->size, sizeof(uint32_t));
@@ -11214,10 +13936,12 @@
void reservedmarshal_VkBindVertexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindVertexBufferIndirectCommandNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->bufferAddress, sizeof(VkDeviceAddress));
*ptr += sizeof(VkDeviceAddress);
memcpy(*ptr, (uint32_t*)&forMarshaling->size, sizeof(uint32_t));
@@ -11228,20 +13952,24 @@
void reservedmarshal_VkSetStateFlagsIndirectCommandNV(
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)vkStream;
+ (void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -11252,13 +13980,19 @@
void reservedmarshal_VkIndirectCommandsLayoutTokenNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutTokenNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkIndirectCommandsTokenTypeNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->stream, sizeof(uint32_t));
@@ -11291,13 +14025,19 @@
void reservedmarshal_VkIndirectCommandsLayoutCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkIndirectCommandsLayoutUsageFlagsNV);
memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
@@ -11306,7 +14046,7 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i)
{
- reservedmarshal_VkIndirectCommandsLayoutTokenNV(vkStream, (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i), ptr);
+ reservedmarshal_VkIndirectCommandsLayoutTokenNV(vkStream, rootType, (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->streamCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -11316,13 +14056,19 @@
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);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
@@ -11337,7 +14083,7 @@
*ptr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)forMarshaling->streamCount; ++i)
{
- reservedmarshal_VkIndirectCommandsStreamNV(vkStream, (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i), ptr);
+ reservedmarshal_VkIndirectCommandsStreamNV(vkStream, rootType, (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->sequencesCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -11365,13 +14111,19 @@
void reservedmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
@@ -11390,26 +14142,38 @@
#ifdef VK_EXT_texel_buffer_alignment
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->texelBufferAlignment, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment, sizeof(VkBool32));
@@ -11424,55 +14188,79 @@
#ifdef VK_QCOM_render_pass_transform
void reservedmarshal_VkRenderPassTransformBeginInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassTransformBeginInfoQCOM* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
}
void reservedmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
- reservedmarshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea), ptr);
+ reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea), ptr);
}
#endif
#ifdef VK_EXT_device_memory_report
void reservedmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->deviceMemoryReport, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkDeviceMemoryReportCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryReportCallbackDataEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceMemoryReportFlagsEXT);
memcpy(*ptr, (VkDeviceMemoryReportEventTypeEXT*)&forMarshaling->type, sizeof(VkDeviceMemoryReportEventTypeEXT));
@@ -11491,13 +14279,19 @@
void reservedmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceMemoryReportFlagsEXT);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
@@ -11512,13 +14306,19 @@
#ifdef VK_EXT_robustness2
void reservedmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->robustBufferAccess2, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->robustImageAccess2, sizeof(VkBool32));
@@ -11529,13 +14329,19 @@
void reservedmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->robustUniformBufferAccessSizeAlignment, sizeof(VkDeviceSize));
@@ -11546,40 +14352,58 @@
#ifdef VK_EXT_custom_border_color
void reservedmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forMarshaling->customBorderColor), ptr);
+ 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);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
}
void reservedmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxCustomBorderColorSamplers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->customBorderColors, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->customBorderColorWithoutFormat, sizeof(VkBool32));
@@ -11592,39 +14416,57 @@
#ifdef VK_EXT_private_data
void reservedmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->privateData, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkDevicePrivateDataCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDevicePrivateDataCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkPrivateDataSlotCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPrivateDataSlotCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkPrivateDataSlotCreateFlagsEXT);
}
@@ -11633,13 +14475,19 @@
#ifdef VK_EXT_pipeline_creation_cache_control
void reservedmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -11648,26 +14496,38 @@
#ifdef VK_NV_device_diagnostics_config
void reservedmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->diagnosticsConfig, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDeviceDiagnosticsConfigFlagsNV);
}
@@ -11678,13 +14538,19 @@
#ifdef VK_NV_fragment_shading_rate_enums
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateEnums, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->supersampleFragmentShadingRates, sizeof(VkBool32));
@@ -11695,26 +14561,38 @@
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSampleCountFlagBits);
}
void reservedmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkFragmentShadingRateTypeNV);
memcpy(*ptr, (VkFragmentShadingRateNV*)&forMarshaling->shadingRate, sizeof(VkFragmentShadingRateNV));
@@ -11727,26 +14605,38 @@
#ifdef VK_EXT_fragment_density_map2
void reservedmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityMapDeferred, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -11761,13 +14651,19 @@
#ifdef VK_QCOM_rotated_copy_commands
void reservedmarshal_VkCopyCommandTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyCommandTransformInfoQCOM* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
}
@@ -11776,13 +14672,19 @@
#ifdef VK_EXT_image_robustness
void reservedmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->robustImageAccess, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -11791,13 +14693,19 @@
#ifdef VK_EXT_4444_formats
void reservedmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->formatA4R4G4B4, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->formatA4B4G4R4, sizeof(VkBool32));
@@ -11808,13 +14716,19 @@
#ifdef VK_EXT_directfb_surface
void reservedmarshal_VkDirectFBSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDirectFBSurfaceCreateInfoEXT* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkDirectFBSurfaceCreateFlagsEXT);
// WARNING PTR CHECK
@@ -11841,34 +14755,105 @@
#endif
#ifdef VK_GOOGLE_gfxstream
+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)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->colorBuffer, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+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)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->buffer, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+void reservedmarshal_VkImportPhysicalAddressGOOGLE(
+ 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)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint64_t*)&forMarshaling->physicalAddress, sizeof(uint64_t));
+ *ptr += sizeof(uint64_t);
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ *ptr += sizeof(VkDeviceSize);
+ memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+ *ptr += sizeof(VkFormat);
+ memcpy(*ptr, (VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
+ *ptr += sizeof(VkImageTiling);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->tilingParameter, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
#endif
#ifdef VK_KHR_acceleration_structure
void reservedmarshal_VkDeviceOrHostAddressKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceOrHostAddressKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
*ptr += sizeof(VkDeviceAddress);
}
void reservedmarshal_VkDeviceOrHostAddressConstKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceOrHostAddressConstKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
*ptr += sizeof(VkDeviceAddress);
}
void reservedmarshal_VkAccelerationStructureBuildRangeInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->primitiveCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->primitiveOffset, sizeof(uint32_t));
@@ -11881,88 +14866,120 @@
void reservedmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (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, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexData), ptr);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data), ptr);
+ 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);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
}
void reservedmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (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)
{
(void)vkStream;
- reservedmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles), ptr);
+ (void)rootType;
+ reservedmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles), ptr);
}
void reservedmarshal_VkAccelerationStructureGeometryKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkAccelerationStructureTypeKHR);
memcpy(*ptr, (VkBuildAccelerationStructureFlagsKHR*)&forMarshaling->flags, sizeof(VkBuildAccelerationStructureFlagsKHR));
@@ -11988,21 +15005,27 @@
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i)
{
- reservedmarshal_VkAccelerationStructureGeometryKHR(vkStream, (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i), ptr);
+ reservedmarshal_VkAccelerationStructureGeometryKHR(vkStream, rootType, (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i), ptr);
}
}
- reservedmarshal_VkDeviceOrHostAddressKHR(vkStream, (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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkAccelerationStructureCreateFlagsKHR);
uint64_t cgen_var_0;
@@ -12021,13 +15044,19 @@
void reservedmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->accelerationStructureCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
@@ -12055,13 +15084,19 @@
void reservedmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->accelerationStructure, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->accelerationStructureCaptureReplay, sizeof(VkBool32));
@@ -12076,13 +15111,19 @@
void reservedmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint64_t*)&forMarshaling->maxGeometryCount, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
memcpy(*ptr, (uint64_t*)&forMarshaling->maxInstanceCount, sizeof(uint64_t));
@@ -12103,13 +15144,19 @@
void reservedmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -12118,45 +15165,63 @@
void reservedmarshal_VkAccelerationStructureVersionInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureVersionInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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);
}
void reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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->src));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- reservedmarshal_VkDeviceOrHostAddressKHR(vkStream, (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst), ptr);
+ 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)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src), ptr);
+ 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);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->dst));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -12167,13 +15232,19 @@
void reservedmarshal_VkCopyAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyAccelerationStructureInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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->src));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -12188,13 +15259,19 @@
void reservedmarshal_VkAccelerationStructureBuildSizesInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->accelerationStructureSize, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->updateScratchSize, sizeof(VkDeviceSize));
@@ -12207,13 +15284,19 @@
#ifdef VK_KHR_ray_tracing_pipeline
void reservedmarshal_VkRayTracingShaderGroupCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
*ptr += sizeof(VkRayTracingShaderGroupTypeKHR);
memcpy(*ptr, (uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
@@ -12238,13 +15321,19 @@
void reservedmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPipelineRayPayloadSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPipelineRayHitAttributeSize, sizeof(uint32_t));
@@ -12253,26 +15342,32 @@
void reservedmarshal_VkRayTracingPipelineCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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);
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, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
+ 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, (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i), ptr);
+ reservedmarshal_VkRayTracingShaderGroupCreateInfoKHR(vkStream, rootType, (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -12283,7 +15378,7 @@
*ptr += 8;
if (forMarshaling->pLibraryInfo)
{
- reservedmarshal_VkPipelineLibraryCreateInfoKHR(vkStream, (const VkPipelineLibraryCreateInfoKHR*)(forMarshaling->pLibraryInfo), ptr);
+ reservedmarshal_VkPipelineLibraryCreateInfoKHR(vkStream, rootType, (const VkPipelineLibraryCreateInfoKHR*)(forMarshaling->pLibraryInfo), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pLibraryInterface;
@@ -12292,7 +15387,7 @@
*ptr += 8;
if (forMarshaling->pLibraryInterface)
{
- reservedmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(vkStream, (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(forMarshaling->pLibraryInterface), ptr);
+ reservedmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(vkStream, rootType, (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(forMarshaling->pLibraryInterface), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
@@ -12301,7 +15396,7 @@
*ptr += 8;
if (forMarshaling->pDynamicState)
{
- reservedmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
+ reservedmarshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
}
uint64_t cgen_var_3;
*&cgen_var_3 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
@@ -12317,13 +15412,19 @@
void reservedmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ 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));
@@ -12338,13 +15439,19 @@
void reservedmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->shaderGroupHandleSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxRayRecursionDepth, sizeof(uint32_t));
@@ -12365,10 +15472,12 @@
void reservedmarshal_VkStridedDeviceAddressRegionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStridedDeviceAddressRegionKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
*ptr += sizeof(VkDeviceAddress);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
@@ -12379,10 +15488,12 @@
void reservedmarshal_VkTraceRaysIndirectCommandKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTraceRaysIndirectCommandKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->height, sizeof(uint32_t));
@@ -12395,13 +15506,19 @@
#ifdef VK_KHR_ray_query
void reservedmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling,
uint8_t** ptr)
{
(void)vkStream;
+ (void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- reservedmarshal_extension_struct(vkStream, forMarshaling->pNext, ptr);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
+ {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->rayQuery, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -12409,15 +15526,16 @@
#endif
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(), 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, (void*)structAccess->pNext, ptr);
+ reservedmarshal_extension_struct(vkStream, rootType, (void*)structAccess->pNext, ptr);
return;
}
else
@@ -12442,1535 +15560,1613 @@
#ifdef VK_VERSION_1_1
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceSubgroupProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceSubgroupProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
{
- reservedmarshal_VkPhysicalDevice16BitStorageFeatures(vkStream, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDevice16BitStorageFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
{
- reservedmarshal_VkMemoryDedicatedRequirements(vkStream, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), ptr);
+ reservedmarshal_VkMemoryDedicatedRequirements(vkStream, rootType, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
{
- reservedmarshal_VkMemoryDedicatedAllocateInfo(vkStream, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), ptr);
+ reservedmarshal_VkMemoryDedicatedAllocateInfo(vkStream, rootType, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
{
- reservedmarshal_VkMemoryAllocateFlagsInfo(vkStream, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), ptr);
+ reservedmarshal_VkMemoryAllocateFlagsInfo(vkStream, rootType, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
{
- reservedmarshal_VkDeviceGroupRenderPassBeginInfo(vkStream, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), ptr);
+ reservedmarshal_VkDeviceGroupRenderPassBeginInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
{
- reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), ptr);
+ reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
{
- reservedmarshal_VkDeviceGroupSubmitInfo(vkStream, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), ptr);
+ reservedmarshal_VkDeviceGroupSubmitInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
{
- reservedmarshal_VkDeviceGroupBindSparseInfo(vkStream, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), ptr);
+ reservedmarshal_VkDeviceGroupBindSparseInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
{
- reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), ptr);
+ reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
{
- reservedmarshal_VkBindImageMemoryDeviceGroupInfo(vkStream, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), ptr);
+ reservedmarshal_VkBindImageMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
{
- reservedmarshal_VkDeviceGroupDeviceCreateInfo(vkStream, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkDeviceGroupDeviceCreateInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
{
- reservedmarshal_VkPhysicalDeviceFeatures2(vkStream, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceFeatures2(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
{
- reservedmarshal_VkPhysicalDevicePointClippingProperties(vkStream, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
{
- reservedmarshal_VkImageViewUsageCreateInfo(vkStream, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, rootType, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
{
- reservedmarshal_VkRenderPassMultiviewCreateInfo(vkStream, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkRenderPassMultiviewCreateInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceMultiviewFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceMultiviewFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceMultiviewProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceMultiviewProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
{
- reservedmarshal_VkProtectedSubmitInfo(vkStream, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), ptr);
+ reservedmarshal_VkProtectedSubmitInfo(vkStream, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
{
- reservedmarshal_VkSamplerYcbcrConversionInfo(vkStream, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), ptr);
+ reservedmarshal_VkSamplerYcbcrConversionInfo(vkStream, rootType, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
{
- reservedmarshal_VkBindImagePlaneMemoryInfo(vkStream, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), ptr);
+ reservedmarshal_VkBindImagePlaneMemoryInfo(vkStream, rootType, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
{
- reservedmarshal_VkImagePlaneMemoryRequirementsInfo(vkStream, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), ptr);
+ reservedmarshal_VkImagePlaneMemoryRequirementsInfo(vkStream, rootType, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
{
- reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), ptr);
+ reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, rootType, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
{
- reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
{
- reservedmarshal_VkExternalImageFormatProperties(vkStream, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), ptr);
+ reservedmarshal_VkExternalImageFormatProperties(vkStream, rootType, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceIDProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceIDProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
{
- reservedmarshal_VkExternalMemoryImageCreateInfo(vkStream, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkExternalMemoryImageCreateInfo(vkStream, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
{
- reservedmarshal_VkExternalMemoryBufferCreateInfo(vkStream, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkExternalMemoryBufferCreateInfo(vkStream, rootType, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
{
- reservedmarshal_VkExportMemoryAllocateInfo(vkStream, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), ptr);
+ reservedmarshal_VkExportMemoryAllocateInfo(vkStream, rootType, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
{
- reservedmarshal_VkExportFenceCreateInfo(vkStream, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkExportFenceCreateInfo(vkStream, rootType, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
{
- reservedmarshal_VkExportSemaphoreCreateInfo(vkStream, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkExportSemaphoreCreateInfo(vkStream, rootType, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceMaintenance3Properties(vkStream, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceMaintenance3Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceVulkan11Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceVulkan11Properties(vkStream, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceVulkan11Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceVulkan12Features(vkStream, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceVulkan12Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceVulkan12Properties(vkStream, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceVulkan12Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
{
- reservedmarshal_VkImageFormatListCreateInfo(vkStream, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkImageFormatListCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
{
- reservedmarshal_VkPhysicalDevice8BitStorageFeatures(vkStream, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDevice8BitStorageFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceDriverProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceDriverProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceFloatControlsProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkStream, rootType, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), ptr);
+ reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkStream, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
{
- reservedmarshal_VkSubpassDescriptionDepthStencilResolve(vkStream, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), ptr);
+ reservedmarshal_VkSubpassDescriptionDepthStencilResolve(vkStream, rootType, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
{
- reservedmarshal_VkImageStencilUsageCreateInfo(vkStream, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkImageStencilUsageCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
{
- reservedmarshal_VkSamplerReductionModeCreateInfo(vkStream, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkSamplerReductionModeCreateInfo(vkStream, rootType, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
{
- reservedmarshal_VkFramebufferAttachmentsCreateInfo(vkStream, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkFramebufferAttachmentsCreateInfo(vkStream, rootType, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
{
- reservedmarshal_VkRenderPassAttachmentBeginInfo(vkStream, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
{
- reservedmarshal_VkAttachmentReferenceStencilLayout(vkStream, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), ptr);
+ reservedmarshal_VkAttachmentReferenceStencilLayout(vkStream, rootType, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
{
- reservedmarshal_VkAttachmentDescriptionStencilLayout(vkStream, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), ptr);
+ reservedmarshal_VkAttachmentDescriptionStencilLayout(vkStream, rootType, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
{
- reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
{
- reservedmarshal_VkSemaphoreTypeCreateInfo(vkStream, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkSemaphoreTypeCreateInfo(vkStream, rootType, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
{
- reservedmarshal_VkTimelineSemaphoreSubmitInfo(vkStream, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), ptr);
+ reservedmarshal_VkTimelineSemaphoreSubmitInfo(vkStream, rootType, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
{
- reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
{
- reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), ptr);
+ reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, rootType, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
{
- reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(vkStream, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), ptr);
+ reservedmarshal_VkImageSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
{
- reservedmarshal_VkBindImageMemorySwapchainInfoKHR(vkStream, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), ptr);
+ reservedmarshal_VkBindImageMemorySwapchainInfoKHR(vkStream, rootType, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
{
- reservedmarshal_VkDeviceGroupPresentInfoKHR(vkStream, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), ptr);
+ reservedmarshal_VkDeviceGroupPresentInfoKHR(vkStream, rootType, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
{
- reservedmarshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), ptr);
+ reservedmarshal_VkDisplayPresentInfoKHR(vkStream, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- reservedmarshal_VkImportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), ptr);
+ reservedmarshal_VkImportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
{
- reservedmarshal_VkExportMemoryWin32HandleInfoKHR(vkStream, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), ptr);
+ reservedmarshal_VkExportSemaphoreWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
{
- reservedmarshal_VkD3D12FenceSubmitInfoKHR(vkStream, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
{
- reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
{
- reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), ptr);
+ reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
{
- reservedmarshal_VkPerformanceQuerySubmitInfoKHR(vkStream, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
{
- reservedmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), ptr);
+ reservedmarshal_VkSurfaceProtectedCapabilitiesKHR(vkStream, rootType, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
{
- reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
{
- reservedmarshal_VkNativeBufferANDROID(vkStream, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), ptr);
+ reservedmarshal_VkDedicatedAllocationImageCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
{
- reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), ptr);
+ reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
{
- reservedmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
{
- reservedmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), ptr);
+ reservedmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
{
- reservedmarshal_VkTextureLODGatherFormatPropertiesAMD(vkStream, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), ptr);
+ reservedmarshal_VkExternalMemoryImageCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
{
- reservedmarshal_VkExportMemoryAllocateInfoNV(vkStream, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), ptr);
+ reservedmarshal_VkImportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
{
- reservedmarshal_VkExportMemoryWin32HandleInfoNV(vkStream, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), ptr);
+ reservedmarshal_VkImageViewASTCDecodeModeEXT(vkStream, rootType, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
{
- reservedmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), ptr);
+ reservedmarshal_VkAndroidHardwareBufferUsageANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
{
- reservedmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), ptr);
+ reservedmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
{
- reservedmarshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), ptr);
+ reservedmarshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, rootType, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
{
- reservedmarshal_VkExternalFormatANDROID(vkStream, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), ptr);
+ reservedmarshal_VkExternalFormatANDROID(vkStream, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
{
- reservedmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), ptr);
+ reservedmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
{
- reservedmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), ptr);
+ reservedmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_validation_cache
case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
{
- reservedmarshal_VkShaderModuleValidationCacheCreateInfoEXT(vkStream, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), ptr);
+ reservedmarshal_VkWriteDescriptorSetAccelerationStructureNV(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
{
- reservedmarshal_VkPhysicalDeviceRayTracingPropertiesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
{
- reservedmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(vkStream, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
{
- reservedmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), ptr);
+ reservedmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
{
- reservedmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), ptr);
+ reservedmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(vkStream, rootType, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), ptr);
break;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- reservedmarshal_VkImportColorBufferGOOGLE(vkStream, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), ptr);
+ 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);
+ break;
+ }
+ 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);
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- reservedmarshal_VkImportBufferGOOGLE(vkStream, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), ptr);
+ 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);
+ break;
+ }
+ default:
+ {
+ reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), ptr);
+ break;
+ }
+ }
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- reservedmarshal_VkImportPhysicalAddressGOOGLE(vkStream, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), ptr);
+ 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);
+ break;
+ }
+ 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);
+ break;
+ }
+ }
break;
}
#endif
#ifdef VK_EXT_subgroup_size_control
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
{
- reservedmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
{
- reservedmarshal_VkMemoryPriorityAllocateInfoEXT(vkStream, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
{
- reservedmarshal_VkBufferDeviceAddressCreateInfoEXT(vkStream, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
{
- reservedmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(vkStream, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
{
- reservedmarshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), ptr);
+ reservedmarshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
{
- reservedmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(vkStream, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
{
- reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(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, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), ptr);
+ reservedmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
{
- reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
{
- reservedmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
{
- reservedmarshal_VkDevicePrivateDataCreateInfoEXT(vkStream, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
{
- reservedmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(vkStream, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension), ptr);
+ reservedmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(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, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(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);
+ break;
+ }
+ 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);
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
- reservedmarshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), ptr);
+ reservedmarshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
{
- reservedmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), ptr);
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
{
- reservedmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(vkStream, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension), ptr);
+ 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, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), ptr);
+ reservedmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), ptr);
break;
}
#endif
diff --git a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
index ac5f12a..6984b87 100644
--- a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
@@ -46,546 +46,655 @@
#ifdef VK_VERSION_1_0
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_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_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_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_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_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_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_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_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_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_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_VkPhysicalDeviceLimits(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLimits* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMemoryProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSparseProperties(
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_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_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_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_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_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_VkSparseBufferMemoryBindInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseBufferMemoryBindInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSparseImageOpaqueMemoryBindInfo(
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_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_VkBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindSparseInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSparseImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageFormatProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSparseImageMemoryRequirements(
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_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_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_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_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_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_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_VkSpecializationInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSpecializationInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineShaderStageCreateInfo(
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_VkVertexInputBindingDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputBindingDescription* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkVertexInputAttributeDescription(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputAttributeDescription* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineVertexInputStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineVertexInputStateCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineInputAssemblyStateCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineTessellationStateCreateInfo(
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_VkPipelineViewportStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportStateCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineMultisampleStateCreateInfo(
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_VkPipelineDepthStencilStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDepthStencilStateCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineColorBlendAttachmentState(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendAttachmentState* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineColorBlendStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendStateCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineDynamicStateCreateInfo(
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_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_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_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_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_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_VkDescriptorSetLayoutCreateInfo(
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_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_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_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_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_VkCommandBufferInheritanceInfo(
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_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_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_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_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_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_VkImageResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageResolve* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassBeginInfo* forMarshaling,
uint8_t** ptr);
@@ -593,191 +702,229 @@
#ifdef VK_VERSION_1_1
void reservedmarshal_VkPhysicalDeviceSubgroupProperties(
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_VkBindImageMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemoryInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDevice16BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice16BitStorageFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMemoryDedicatedRequirements(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryDedicatedRequirements* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMemoryDedicatedAllocateInfo(
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_VkDeviceGroupRenderPassBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupRenderPassBeginInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(
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_VkDeviceGroupBindSparseInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupBindSparseInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindBufferMemoryDeviceGroupInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkBindImageMemoryDeviceGroupInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImageMemoryDeviceGroupInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceGroupProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceGroupProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDeviceGroupDeviceCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupDeviceCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkBufferMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferMemoryRequirementsInfo2* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkImageMemoryRequirementsInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageMemoryRequirementsInfo2* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkImageSparseMemoryRequirementsInfo2(
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_VkSparseImageMemoryRequirements2(
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_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_VkImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageFormatProperties2* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceImageFormatInfo2(
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_VkPhysicalDeviceMemoryProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties2* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSparseImageFormatProperties2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSparseImageFormatProperties2* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDevicePointClippingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePointClippingProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkInputAttachmentAspectReference(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkInputAttachmentAspectReference* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
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_VkPipelineTessellationDomainOriginStateCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkRenderPassMultiviewCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassMultiviewCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMultiviewFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMultiviewProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* forMarshaling,
uint8_t** ptr);
@@ -785,151 +932,181 @@
void reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(
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_VkProtectedSubmitInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkProtectedSubmitInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSamplerYcbcrConversionCreateInfo(
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_VkBindImagePlaneMemoryInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindImagePlaneMemoryInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkImagePlaneMemoryRequirementsInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImagePlaneMemoryRequirementsInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDescriptorUpdateTemplateEntry(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorUpdateTemplateEntry* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(
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_VkPhysicalDeviceExternalImageFormatInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExternalImageFormatProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalImageFormatProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExternalBufferInfo(
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_VkPhysicalDeviceIDProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceIDProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExternalMemoryImageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExternalMemoryBufferCreateInfo(
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_VkPhysicalDeviceExternalFenceInfo(
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_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_VkPhysicalDeviceExternalSemaphoreInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExternalSemaphoreProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalSemaphoreProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMaintenance3Properties(
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_VkPhysicalDeviceShaderDrawParametersFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling,
uint8_t** ptr);
@@ -939,256 +1116,307 @@
#ifdef VK_VERSION_1_2
void reservedmarshal_VkPhysicalDeviceVulkan11Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Features* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVulkan11Properties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkan11Properties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVulkan12Features(
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_VkPhysicalDeviceVulkan12Properties(
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_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_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_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_VkSubpassEndInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassEndInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDevice8BitStorageFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice8BitStorageFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDriverProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDriverProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFloatControlsProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFloatControlsProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSubpassDescriptionDepthStencilResolve(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSubpassDescriptionDepthStencilResolve* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkImageStencilUsageCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageStencilUsageCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSamplerReductionModeCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerReductionModeCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkFramebufferAttachmentImageInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferAttachmentImageInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkFramebufferAttachmentsCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferAttachmentsCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkRenderPassAttachmentBeginInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassAttachmentBeginInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAttachmentReferenceStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentReferenceStencilLayout* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAttachmentDescriptionStencilLayout(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAttachmentDescriptionStencilLayout* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
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_VkTimelineSemaphoreSubmitInfo(
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_VkSemaphoreSignalInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreSignalInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
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_VkBufferOpaqueCaptureAddressCreateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling,
uint8_t** ptr);
@@ -1196,11 +1424,13 @@
#ifdef VK_KHR_surface
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);
@@ -1208,41 +1438,49 @@
#ifdef VK_KHR_swapchain
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_VkImageSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageSwapchainCreateInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkBindImageMemorySwapchainInfoKHR(
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_VkDeviceGroupPresentCapabilitiesKHR(
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_VkDeviceGroupSwapchainCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1250,36 +1488,43 @@
#ifdef VK_KHR_display
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_VkDisplayModePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayModePropertiesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDisplayPlaneCapabilitiesKHR(
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_VkDisplayPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPropertiesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDisplaySurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplaySurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1287,6 +1532,7 @@
#ifdef VK_KHR_display_swapchain
void reservedmarshal_VkDisplayPresentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPresentInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1294,6 +1540,7 @@
#ifdef VK_KHR_xlib_surface
void reservedmarshal_VkXlibSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXlibSurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1301,6 +1548,7 @@
#ifdef VK_KHR_xcb_surface
void reservedmarshal_VkXcbSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkXcbSurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1308,6 +1556,7 @@
#ifdef VK_KHR_wayland_surface
void reservedmarshal_VkWaylandSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWaylandSurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1315,6 +1564,7 @@
#ifdef VK_KHR_android_surface
void reservedmarshal_VkAndroidSurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidSurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1322,6 +1572,7 @@
#ifdef VK_KHR_win32_surface
void reservedmarshal_VkWin32SurfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32SurfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1407,21 +1658,25 @@
#ifdef VK_KHR_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExportMemoryWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMemoryWin32HandlePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryWin32HandlePropertiesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMemoryGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1429,16 +1684,19 @@
#ifdef VK_KHR_external_memory_fd
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_VkMemoryGetFdInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetFdInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1446,6 +1704,7 @@
#ifdef VK_KHR_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1463,21 +1722,25 @@
#ifdef VK_KHR_external_semaphore_win32
void reservedmarshal_VkImportSemaphoreWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExportSemaphoreWin32HandleInfoKHR(
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_VkSemaphoreGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1485,11 +1748,13 @@
#ifdef VK_KHR_external_semaphore_fd
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);
@@ -1497,6 +1762,7 @@
#ifdef VK_KHR_push_descriptor
void reservedmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling,
uint8_t** ptr);
@@ -1514,16 +1780,19 @@
#ifdef VK_KHR_incremental_present
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_VkPresentRegionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentRegionsKHR* forMarshaling,
uint8_t** ptr);
@@ -1563,6 +1832,7 @@
#ifdef VK_KHR_shared_presentable_image
void reservedmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling,
uint8_t** ptr);
@@ -1580,16 +1850,19 @@
#ifdef VK_KHR_external_fence_win32
void reservedmarshal_VkImportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportFenceWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExportFenceWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportFenceWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkFenceGetWin32HandleInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFenceGetWin32HandleInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1597,11 +1870,13 @@
#ifdef VK_KHR_external_fence_fd
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);
@@ -1609,41 +1884,49 @@
#ifdef VK_KHR_performance_query
void reservedmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
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_VkPerformanceCounterDescriptionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceCounterDescriptionKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPerformanceCounterResultKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceCounterResultKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAcquireProfilingLockInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAcquireProfilingLockInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPerformanceQuerySubmitInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceQuerySubmitInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1663,16 +1946,19 @@
#ifdef VK_KHR_get_surface_capabilities2
void reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
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_VkSurfaceFormat2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFormat2KHR* forMarshaling,
uint8_t** ptr);
@@ -1686,26 +1972,31 @@
#ifdef VK_KHR_get_display_properties2
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_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_VkDisplayPlaneCapabilities2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayPlaneCapabilities2KHR* forMarshaling,
uint8_t** ptr);
@@ -1759,11 +2050,13 @@
#ifdef VK_KHR_portability_subset
void reservedmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling,
uint8_t** ptr);
@@ -1791,6 +2084,7 @@
#ifdef VK_KHR_shader_clock
void reservedmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling,
uint8_t** ptr);
@@ -1834,6 +2128,7 @@
#ifdef VK_KHR_shader_terminate_invocation
void reservedmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling,
uint8_t** ptr);
@@ -1841,26 +2136,31 @@
#ifdef VK_KHR_fragment_shading_rate
void reservedmarshal_VkFragmentShadingRateAttachmentInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling,
uint8_t** ptr);
@@ -1870,6 +2170,7 @@
#ifdef VK_KHR_surface_protected_capabilities
void reservedmarshal_VkSurfaceProtectedCapabilitiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceProtectedCapabilitiesKHR* forMarshaling,
uint8_t** ptr);
@@ -1903,36 +2204,43 @@
#ifdef VK_KHR_pipeline_executable_properties
void reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
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_VkPipelineExecutablePropertiesKHR(
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_VkPipelineExecutableStatisticValueKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticValueKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineExecutableStatisticKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableStatisticKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineExecutableInternalRepresentationKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* forMarshaling,
uint8_t** ptr);
@@ -1940,6 +2248,7 @@
#ifdef VK_KHR_pipeline_library
void reservedmarshal_VkPipelineLibraryCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineLibraryCreateInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -1949,56 +2258,67 @@
#ifdef VK_KHR_copy_commands2
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_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_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_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_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_VkResolveImageInfo2KHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkResolveImageInfo2KHR* forMarshaling,
uint8_t** ptr);
@@ -2006,6 +2326,7 @@
#ifdef VK_ANDROID_native_buffer
void reservedmarshal_VkNativeBufferANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkNativeBufferANDROID* forMarshaling,
uint8_t** ptr);
@@ -2013,6 +2334,7 @@
#ifdef VK_EXT_debug_report
void reservedmarshal_VkDebugReportCallbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugReportCallbackCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2026,6 +2348,7 @@
#ifdef VK_AMD_rasterization_order
void reservedmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling,
uint8_t** ptr);
@@ -2037,16 +2360,19 @@
#ifdef VK_EXT_debug_marker
void reservedmarshal_VkDebugMarkerObjectNameInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerObjectNameInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDebugMarkerObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerObjectTagInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDebugMarkerMarkerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugMarkerMarkerInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2056,16 +2382,19 @@
#ifdef VK_NV_dedicated_allocation
void reservedmarshal_VkDedicatedAllocationImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationImageCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling,
uint8_t** ptr);
@@ -2073,16 +2402,19 @@
#ifdef VK_EXT_transform_feedback
void reservedmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2090,11 +2422,13 @@
#ifdef VK_NVX_image_view_handle
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);
@@ -2110,6 +2444,7 @@
#ifdef VK_AMD_texture_gather_bias_lod
void reservedmarshal_VkTextureLODGatherFormatPropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* forMarshaling,
uint8_t** ptr);
@@ -2117,11 +2452,13 @@
#ifdef VK_AMD_shader_info
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);
@@ -2131,6 +2468,7 @@
#ifdef VK_GGP_stream_descriptor_surface
void reservedmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling,
uint8_t** ptr);
@@ -2138,6 +2476,7 @@
#ifdef VK_NV_corner_sampled_image
void reservedmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling,
uint8_t** ptr);
@@ -2147,6 +2486,7 @@
#ifdef VK_NV_external_memory_capabilities
void reservedmarshal_VkExternalImageFormatPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalImageFormatPropertiesNV* forMarshaling,
uint8_t** ptr);
@@ -2154,11 +2494,13 @@
#ifdef VK_NV_external_memory
void reservedmarshal_VkExternalMemoryImageCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalMemoryImageCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExportMemoryAllocateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryAllocateInfoNV* forMarshaling,
uint8_t** ptr);
@@ -2166,11 +2508,13 @@
#ifdef VK_NV_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryWin32HandleInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExportMemoryWin32HandleInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExportMemoryWin32HandleInfoNV* forMarshaling,
uint8_t** ptr);
@@ -2178,6 +2522,7 @@
#ifdef VK_NV_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling,
uint8_t** ptr);
@@ -2185,6 +2530,7 @@
#ifdef VK_EXT_validation_flags
void reservedmarshal_VkValidationFlagsEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationFlagsEXT* forMarshaling,
uint8_t** ptr);
@@ -2192,6 +2538,7 @@
#ifdef VK_NN_vi_surface
void reservedmarshal_VkViSurfaceCreateInfoNN(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkViSurfaceCreateInfoNN* forMarshaling,
uint8_t** ptr);
@@ -2203,6 +2550,7 @@
#ifdef VK_EXT_texture_compression_astc_hdr
void reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -2210,11 +2558,13 @@
#ifdef VK_EXT_astc_decode_mode
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);
@@ -2222,16 +2572,19 @@
#ifdef VK_EXT_conditional_rendering
void reservedmarshal_VkConditionalRenderingBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkConditionalRenderingBeginInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2239,11 +2592,13 @@
#ifdef VK_NV_clip_space_w_scaling
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);
@@ -2255,6 +2610,7 @@
#ifdef VK_EXT_display_surface_counter
void reservedmarshal_VkSurfaceCapabilities2EXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilities2EXT* forMarshaling,
uint8_t** ptr);
@@ -2262,21 +2618,25 @@
#ifdef VK_EXT_display_control
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_VkDisplayEventInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayEventInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSwapchainCounterCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainCounterCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2284,21 +2644,25 @@
#ifdef VK_GOOGLE_display_timing
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);
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);
@@ -2312,6 +2676,7 @@
#ifdef VK_NVX_multiview_per_view_attributes
void reservedmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling,
uint8_t** ptr);
@@ -2319,11 +2684,13 @@
#ifdef VK_NV_viewport_swizzle
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);
@@ -2331,11 +2698,13 @@
#ifdef VK_EXT_discard_rectangles
void reservedmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2343,11 +2712,13 @@
#ifdef VK_EXT_conservative_rasterization
void reservedmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2355,11 +2726,13 @@
#ifdef VK_EXT_depth_clip_enable
void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2369,11 +2742,13 @@
#ifdef VK_EXT_hdr_metadata
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);
@@ -2381,6 +2756,7 @@
#ifdef VK_MVK_ios_surface
void reservedmarshal_VkIOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIOSSurfaceCreateInfoMVK* forMarshaling,
uint8_t** ptr);
@@ -2388,6 +2764,7 @@
#ifdef VK_MVK_macos_surface
void reservedmarshal_VkMacOSSurfaceCreateInfoMVK(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMacOSSurfaceCreateInfoMVK* forMarshaling,
uint8_t** ptr);
@@ -2401,26 +2778,31 @@
#ifdef VK_EXT_debug_utils
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);
void reservedmarshal_VkDebugUtilsMessengerCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDebugUtilsObjectTagInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDebugUtilsObjectTagInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2428,31 +2810,37 @@
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void reservedmarshal_VkAndroidHardwareBufferUsageANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferUsageANDROID* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAndroidHardwareBufferPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkImportAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkExternalFormatANDROID(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkExternalFormatANDROID* forMarshaling,
uint8_t** ptr);
@@ -2472,21 +2860,25 @@
#ifdef VK_EXT_inline_uniform_block
void reservedmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2496,41 +2888,49 @@
#ifdef VK_EXT_sample_locations
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_VkAttachmentSampleLocationsEXT(
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_VkRenderPassSampleLocationsBeginInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMultisamplePropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMultisamplePropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -2538,16 +2938,19 @@
#ifdef VK_EXT_blend_operation_advanced
void reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2555,6 +2958,7 @@
#ifdef VK_NV_fragment_coverage_to_color
void reservedmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling,
uint8_t** ptr);
@@ -2562,6 +2966,7 @@
#ifdef VK_NV_framebuffer_mixed_samples
void reservedmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling,
uint8_t** ptr);
@@ -2571,11 +2976,13 @@
#ifdef VK_NV_shader_sm_builtins
void reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling,
uint8_t** ptr);
@@ -2585,31 +2992,37 @@
#ifdef VK_EXT_image_drm_format_modifier
void reservedmarshal_VkDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDrmFormatModifierPropertiesListEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrmFormatModifierPropertiesListEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkImageDrmFormatModifierPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImageDrmFormatModifierPropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -2617,11 +3030,13 @@
#ifdef VK_EXT_validation_cache
void reservedmarshal_VkValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationCacheCreateInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2643,36 +3058,43 @@
#ifdef VK_NV_shading_rate_image
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);
void reservedmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
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_VkCoarseSampleOrderCustomNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCoarseSampleOrderCustomNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling,
uint8_t** ptr);
@@ -2680,66 +3102,79 @@
#ifdef VK_NV_ray_tracing
void reservedmarshal_VkRayTracingShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkRayTracingPipelineCreateInfoNV(
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_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_VkGeometryNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeometryNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkBindAccelerationStructureMemoryInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindAccelerationStructureMemoryInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkWriteDescriptorSetAccelerationStructureNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkTransformMatrixKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTransformMatrixKHR* forMarshaling,
uint8_t** ptr);
@@ -2747,6 +3182,7 @@
void reservedmarshal_VkAabbPositionsKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAabbPositionsKHR* forMarshaling,
uint8_t** ptr);
@@ -2754,6 +3190,7 @@
void reservedmarshal_VkAccelerationStructureInstanceKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureInstanceKHR* forMarshaling,
uint8_t** ptr);
@@ -2763,11 +3200,13 @@
#ifdef VK_NV_representative_fragment_test
void reservedmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling,
uint8_t** ptr);
@@ -2775,11 +3214,13 @@
#ifdef VK_EXT_filter_cubic
void reservedmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -2789,6 +3230,7 @@
#ifdef VK_EXT_global_priority
void reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2796,16 +3238,19 @@
#ifdef VK_EXT_external_memory_host
void reservedmarshal_VkImportMemoryHostPointerInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImportMemoryHostPointerInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMemoryHostPointerPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryHostPointerPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -2815,6 +3260,7 @@
#ifdef VK_AMD_pipeline_compiler_control
void reservedmarshal_VkPipelineCompilerControlCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* forMarshaling,
uint8_t** ptr);
@@ -2822,6 +3268,7 @@
#ifdef VK_EXT_calibrated_timestamps
void reservedmarshal_VkCalibratedTimestampInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCalibratedTimestampInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2829,6 +3276,7 @@
#ifdef VK_AMD_shader_core_properties
void reservedmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling,
uint8_t** ptr);
@@ -2836,6 +3284,7 @@
#ifdef VK_AMD_memory_overallocation_behavior
void reservedmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling,
uint8_t** ptr);
@@ -2843,21 +3292,25 @@
#ifdef VK_EXT_vertex_attribute_divisor
void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkVertexInputBindingDivisorDescriptionEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -2865,6 +3318,7 @@
#ifdef VK_GGP_frame_token
void reservedmarshal_VkPresentFrameTokenGGP(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPresentFrameTokenGGP* forMarshaling,
uint8_t** ptr);
@@ -2872,11 +3326,13 @@
#ifdef VK_EXT_pipeline_creation_feedback
void reservedmarshal_VkPipelineCreationFeedbackEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -2886,6 +3342,7 @@
#ifdef VK_NV_compute_shader_derivatives
void reservedmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling,
uint8_t** ptr);
@@ -2893,16 +3350,19 @@
#ifdef VK_NV_mesh_shader
void reservedmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDrawMeshTasksIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDrawMeshTasksIndirectCommandNV* forMarshaling,
uint8_t** ptr);
@@ -2910,6 +3370,7 @@
#ifdef VK_NV_fragment_shader_barycentric
void reservedmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling,
uint8_t** ptr);
@@ -2917,6 +3378,7 @@
#ifdef VK_NV_shader_image_footprint
void reservedmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling,
uint8_t** ptr);
@@ -2924,11 +3386,13 @@
#ifdef VK_NV_scissor_exclusive
void reservedmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling,
uint8_t** ptr);
@@ -2936,11 +3400,13 @@
#ifdef VK_NV_device_diagnostic_checkpoints
void reservedmarshal_VkQueueFamilyCheckpointPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueueFamilyCheckpointPropertiesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkCheckpointDataNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCheckpointDataNV* forMarshaling,
uint8_t** ptr);
@@ -2948,6 +3414,7 @@
#ifdef VK_INTEL_shader_integer_functions2
void reservedmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling,
uint8_t** ptr);
@@ -2955,21 +3422,25 @@
#ifdef VK_INTEL_performance_query
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_VkInitializePerformanceApiInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkInitializePerformanceApiInfoINTEL* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling,
uint8_t** ptr);
@@ -2977,21 +3448,25 @@
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);
void reservedmarshal_VkPerformanceOverrideInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceOverrideInfoINTEL* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling,
uint8_t** ptr);
@@ -2999,6 +3474,7 @@
#ifdef VK_EXT_pci_bus_info
void reservedmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -3006,11 +3482,13 @@
#ifdef VK_AMD_display_native_hdr
void reservedmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling,
uint8_t** ptr);
@@ -3018,6 +3496,7 @@
#ifdef VK_FUCHSIA_imagepipe_surface
void reservedmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling,
uint8_t** ptr);
@@ -3025,24 +3504,28 @@
#ifdef VK_EXT_metal_surface
void reservedmarshal_VkMetalSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMetalSurfaceCreateInfoEXT* forMarshaling,
uint8_t** ptr);
#endif
-#ifdef VK_GOOGLE_color_buffer
-void reservedmarshal_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
VulkanStreamGuest* vkStream,
- const VkImportColorBufferGOOGLE* forMarshaling,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling,
uint8_t** ptr);
-void reservedmarshal_VkImportBufferGOOGLE(
+void reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
VulkanStreamGuest* vkStream,
- const VkImportBufferGOOGLE* forMarshaling,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling,
uint8_t** ptr);
-void reservedmarshal_VkImportPhysicalAddressGOOGLE(
+void reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
VulkanStreamGuest* vkStream,
- const VkImportPhysicalAddressGOOGLE* forMarshaling,
+ VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling,
uint8_t** ptr);
#endif
@@ -3057,16 +3540,19 @@
#ifdef VK_EXT_subgroup_size_control
void reservedmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -3074,6 +3560,7 @@
#ifdef VK_AMD_shader_core_properties2
void reservedmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling,
uint8_t** ptr);
@@ -3081,6 +3568,7 @@
#ifdef VK_AMD_device_coherent_memory
void reservedmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling,
uint8_t** ptr);
@@ -3088,6 +3576,7 @@
#ifdef VK_EXT_shader_image_atomic_int64
void reservedmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3095,6 +3584,7 @@
#ifdef VK_EXT_memory_budget
void reservedmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -3102,11 +3592,13 @@
#ifdef VK_EXT_memory_priority
void reservedmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkMemoryPriorityAllocateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkMemoryPriorityAllocateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -3114,6 +3606,7 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
void reservedmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling,
uint8_t** ptr);
@@ -3121,6 +3614,7 @@
#ifdef VK_EXT_buffer_device_address
void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3130,6 +3624,7 @@
void reservedmarshal_VkBufferDeviceAddressCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBufferDeviceAddressCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -3137,6 +3632,7 @@
#ifdef VK_EXT_tooling_info
void reservedmarshal_VkPhysicalDeviceToolPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceToolPropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -3148,6 +3644,7 @@
#ifdef VK_EXT_validation_features
void reservedmarshal_VkValidationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkValidationFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3155,16 +3652,19 @@
#ifdef VK_NV_cooperative_matrix
void reservedmarshal_VkCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCooperativeMatrixPropertiesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling,
uint8_t** ptr);
@@ -3172,16 +3672,19 @@
#ifdef VK_NV_coverage_reduction_mode
void reservedmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkFramebufferMixedSamplesCombinationNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* forMarshaling,
uint8_t** ptr);
@@ -3189,6 +3692,7 @@
#ifdef VK_EXT_fragment_shader_interlock
void reservedmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3196,6 +3700,7 @@
#ifdef VK_EXT_ycbcr_image_arrays
void reservedmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3203,16 +3708,19 @@
#ifdef VK_EXT_full_screen_exclusive
void reservedmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling,
uint8_t** ptr);
@@ -3220,6 +3728,7 @@
#ifdef VK_EXT_headless_surface
void reservedmarshal_VkHeadlessSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkHeadlessSurfaceCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -3227,16 +3736,19 @@
#ifdef VK_EXT_line_rasterization
void reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -3244,6 +3756,7 @@
#ifdef VK_EXT_shader_atomic_float
void reservedmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3255,6 +3768,7 @@
#ifdef VK_EXT_index_type_uint8
void reservedmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3262,6 +3776,7 @@
#ifdef VK_EXT_extended_dynamic_state
void reservedmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3269,6 +3784,7 @@
#ifdef VK_EXT_shader_demote_to_helper_invocation
void reservedmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3276,66 +3792,79 @@
#ifdef VK_NV_device_generated_commands
void reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkGraphicsShaderGroupCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsShaderGroupCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkBindShaderGroupIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindShaderGroupIndirectCommandNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkBindIndexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindIndexBufferIndirectCommandNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkBindVertexBufferIndirectCommandNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkBindVertexBufferIndirectCommandNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkSetStateFlagsIndirectCommandNV(
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_VkIndirectCommandsLayoutTokenNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkIndirectCommandsLayoutTokenNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkIndirectCommandsLayoutCreateInfoNV(
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_VkGeneratedCommandsMemoryRequirementsInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling,
uint8_t** ptr);
@@ -3343,11 +3872,13 @@
#ifdef VK_EXT_texel_buffer_alignment
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -3355,11 +3886,13 @@
#ifdef VK_QCOM_render_pass_transform
void reservedmarshal_VkRenderPassTransformBeginInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRenderPassTransformBeginInfoQCOM* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling,
uint8_t** ptr);
@@ -3367,16 +3900,19 @@
#ifdef VK_EXT_device_memory_report
void reservedmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDeviceMemoryReportCallbackDataEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceMemoryReportCallbackDataEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -3384,11 +3920,13 @@
#ifdef VK_EXT_robustness2
void reservedmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -3396,16 +3934,19 @@
#ifdef VK_EXT_custom_border_color
void reservedmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3415,16 +3956,19 @@
#ifdef VK_EXT_private_data
void reservedmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDevicePrivateDataCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDevicePrivateDataCreateInfoEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPrivateDataSlotCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPrivateDataSlotCreateInfoEXT* forMarshaling,
uint8_t** ptr);
@@ -3432,6 +3976,7 @@
#ifdef VK_EXT_pipeline_creation_cache_control
void reservedmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3439,11 +3984,13 @@
#ifdef VK_NV_device_diagnostics_config
void reservedmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling,
uint8_t** ptr);
@@ -3453,16 +4000,19 @@
#ifdef VK_NV_fragment_shading_rate_enums
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling,
uint8_t** ptr);
@@ -3470,11 +4020,13 @@
#ifdef VK_EXT_fragment_density_map2
void reservedmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling,
uint8_t** ptr);
@@ -3482,6 +4034,7 @@
#ifdef VK_QCOM_rotated_copy_commands
void reservedmarshal_VkCopyCommandTransformInfoQCOM(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyCommandTransformInfoQCOM* forMarshaling,
uint8_t** ptr);
@@ -3489,6 +4042,7 @@
#ifdef VK_EXT_image_robustness
void reservedmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3496,6 +4050,7 @@
#ifdef VK_EXT_4444_formats
void reservedmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling,
uint8_t** ptr);
@@ -3503,105 +4058,143 @@
#ifdef VK_EXT_directfb_surface
void reservedmarshal_VkDirectFBSurfaceCreateInfoEXT(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDirectFBSurfaceCreateInfoEXT* forMarshaling,
uint8_t** ptr);
#endif
#ifdef VK_GOOGLE_gfxstream
+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_VkImportPhysicalAddressGOOGLE(
+ VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* 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_VkDeviceOrHostAddressConstKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkDeviceOrHostAddressConstKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureBuildRangeInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryAabbsDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryDataKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryDataKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureGeometryKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureCreateInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureVersionInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureVersionInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkCopyAccelerationStructureInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkCopyAccelerationStructureInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureBuildSizesInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling,
uint8_t** ptr);
@@ -3609,36 +4202,43 @@
#ifdef VK_KHR_ray_tracing_pipeline
void reservedmarshal_VkRayTracingShaderGroupCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkRayTracingPipelineCreateInfoKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkRayTracingPipelineCreateInfoKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkStridedDeviceAddressRegionKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkStridedDeviceAddressRegionKHR* forMarshaling,
uint8_t** ptr);
void reservedmarshal_VkTraceRaysIndirectCommandKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkTraceRaysIndirectCommandKHR* forMarshaling,
uint8_t** ptr);
@@ -3646,6 +4246,7 @@
#ifdef VK_KHR_ray_query
void reservedmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling,
uint8_t** ptr);
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.cpp b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
index bc75720..bcc896b 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -12921,10 +12921,10 @@
}
#endif
-#ifdef VK_GOOGLE_color_buffer
-void transform_tohost_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void transform_tohost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
ResourceTracker* resourceTracker,
- VkImportColorBufferGOOGLE* toTransform)
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform)
{
(void)resourceTracker;
(void)toTransform;
@@ -12934,9 +12934,9 @@
}
}
-void transform_fromhost_VkImportColorBufferGOOGLE(
+void transform_fromhost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
ResourceTracker* resourceTracker,
- VkImportColorBufferGOOGLE* toTransform)
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform)
{
(void)resourceTracker;
(void)toTransform;
@@ -12946,9 +12946,9 @@
}
}
-void transform_tohost_VkImportBufferGOOGLE(
+void transform_tohost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
ResourceTracker* resourceTracker,
- VkImportBufferGOOGLE* toTransform)
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform)
{
(void)resourceTracker;
(void)toTransform;
@@ -12956,11 +12956,13 @@
{
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
+ transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minFragmentDensityTexelSize));
+ transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentDensityTexelSize));
}
-void transform_fromhost_VkImportBufferGOOGLE(
+void transform_fromhost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
ResourceTracker* resourceTracker,
- VkImportBufferGOOGLE* toTransform)
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform)
{
(void)resourceTracker;
(void)toTransform;
@@ -12968,11 +12970,13 @@
{
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
+ transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minFragmentDensityTexelSize));
+ transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentDensityTexelSize));
}
-void transform_tohost_VkImportPhysicalAddressGOOGLE(
+void transform_tohost_VkRenderPassFragmentDensityMapCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform)
+ VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform)
{
(void)resourceTracker;
(void)toTransform;
@@ -12980,11 +12984,12 @@
{
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
+ transform_tohost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(&toTransform->fragmentDensityMapAttachment));
}
-void transform_fromhost_VkImportPhysicalAddressGOOGLE(
+void transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform)
+ VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform)
{
(void)resourceTracker;
(void)toTransform;
@@ -12992,6 +12997,7 @@
{
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
+ transform_fromhost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(&toTransform->fragmentDensityMapAttachment));
}
#endif
@@ -14894,6 +14900,78 @@
#endif
#ifdef VK_GOOGLE_gfxstream
+void transform_tohost_VkImportColorBufferGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportColorBufferGOOGLE* toTransform)
+{
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext)
+ {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkImportColorBufferGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportColorBufferGOOGLE* toTransform)
+{
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext)
+ {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkImportBufferGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportBufferGOOGLE* toTransform)
+{
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext)
+ {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkImportBufferGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportBufferGOOGLE* toTransform)
+{
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext)
+ {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkImportPhysicalAddressGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportPhysicalAddressGOOGLE* toTransform)
+{
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext)
+ {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkImportPhysicalAddressGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportPhysicalAddressGOOGLE* toTransform)
+{
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext)
+ {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
#endif
#ifdef VK_KHR_acceleration_structure
void transform_tohost_VkDeviceOrHostAddressKHR(
@@ -16761,20 +16839,20 @@
break;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- transform_tohost_VkImportColorBufferGOOGLE(resourceTracker, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ transform_tohost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- transform_tohost_VkImportBufferGOOGLE(resourceTracker, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ transform_tohost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- transform_tohost_VkImportPhysicalAddressGOOGLE(resourceTracker, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ transform_tohost_VkRenderPassFragmentDensityMapCreateInfoEXT(resourceTracker, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
break;
}
#endif
@@ -17124,6 +17202,23 @@
break;
}
#endif
+#ifdef VK_GOOGLE_gfxstream
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ {
+ transform_tohost_VkImportPhysicalAddressGOOGLE(resourceTracker, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
@@ -18319,20 +18414,20 @@
break;
}
#endif
-#ifdef VK_GOOGLE_color_buffer
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
+#ifdef VK_EXT_fragment_density_map
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
{
- transform_fromhost_VkImportColorBufferGOOGLE(resourceTracker, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ transform_fromhost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
{
- transform_fromhost_VkImportBufferGOOGLE(resourceTracker, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ transform_fromhost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
{
- transform_fromhost_VkImportPhysicalAddressGOOGLE(resourceTracker, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(resourceTracker, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
break;
}
#endif
@@ -18682,6 +18777,23 @@
break;
}
#endif
+#ifdef VK_GOOGLE_gfxstream
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
+ {
+ transform_fromhost_VkImportPhysicalAddressGOOGLE(resourceTracker, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_KHR_acceleration_structure
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
{
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.h b/system/vulkan_enc/goldfish_vk_transform_guest.h
index 9434787..78262cd 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.h
@@ -4705,30 +4705,30 @@
VkMetalSurfaceCreateInfoEXT* toTransform);
#endif
-#ifdef VK_GOOGLE_color_buffer
-void transform_tohost_VkImportColorBufferGOOGLE(
+#ifdef VK_EXT_fragment_density_map
+void transform_tohost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
ResourceTracker* resourceTracker,
- VkImportColorBufferGOOGLE* toTransform);
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform);
-void transform_fromhost_VkImportColorBufferGOOGLE(
+void transform_fromhost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
ResourceTracker* resourceTracker,
- VkImportColorBufferGOOGLE* toTransform);
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform);
-void transform_tohost_VkImportBufferGOOGLE(
+void transform_tohost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
ResourceTracker* resourceTracker,
- VkImportBufferGOOGLE* toTransform);
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform);
-void transform_fromhost_VkImportBufferGOOGLE(
+void transform_fromhost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
ResourceTracker* resourceTracker,
- VkImportBufferGOOGLE* toTransform);
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform);
-void transform_tohost_VkImportPhysicalAddressGOOGLE(
+void transform_tohost_VkRenderPassFragmentDensityMapCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform);
+ VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform);
-void transform_fromhost_VkImportPhysicalAddressGOOGLE(
+void transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform);
+ VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_scalar_block_layout
@@ -5422,6 +5422,30 @@
#endif
#ifdef VK_GOOGLE_gfxstream
+void transform_tohost_VkImportColorBufferGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportColorBufferGOOGLE* toTransform);
+
+void transform_fromhost_VkImportColorBufferGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportColorBufferGOOGLE* toTransform);
+
+void transform_tohost_VkImportBufferGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportBufferGOOGLE* toTransform);
+
+void transform_fromhost_VkImportBufferGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportBufferGOOGLE* toTransform);
+
+void transform_tohost_VkImportPhysicalAddressGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportPhysicalAddressGOOGLE* toTransform);
+
+void transform_fromhost_VkImportPhysicalAddressGOOGLE(
+ ResourceTracker* resourceTracker,
+ VkImportPhysicalAddressGOOGLE* toTransform);
+
#endif
#ifdef VK_KHR_acceleration_structure
void transform_tohost_VkDeviceOrHostAddressKHR(
diff --git a/system/vulkan_enc/vk_format_info.h b/system/vulkan_enc/vk_format_info.h
index d80d9c3..f96d59e 100644
--- a/system/vulkan_enc/vk_format_info.h
+++ b/system/vulkan_enc/vk_format_info.h
@@ -107,6 +107,7 @@
case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
case OMX_COLOR_FormatYUV420Planar:
case HAL_PIXEL_FORMAT_YV12:
+ case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
return true;
default:
diff --git a/system/vulkan_enc/vk_struct_id.h b/system/vulkan_enc/vk_struct_id.h
index 0aaf7a9..5cfb795 100644
--- a/system/vulkan_enc/vk_struct_id.h
+++ b/system/vulkan_enc/vk_struct_id.h
@@ -44,7 +44,7 @@
REGISTER_VK_STRUCT_ID(VkImportColorBufferGOOGLE, VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE);
REGISTER_VK_STRUCT_ID(VkImageViewCreateInfo, VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkImportMemoryBufferCollectionFUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA);
-REGISTER_VK_STRUCT_ID(VkImportMemoryZirconHandleInfoFUCHSIA, VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA);
+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(VkSamplerCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
@@ -53,5 +53,8 @@
REGISTER_VK_STRUCT_ID(VkExportFenceCreateInfo, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkImportBufferGOOGLE, VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE);
REGISTER_VK_STRUCT_ID(VkExternalImageFormatProperties, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceImageFormatInfo2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalImageFormatInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
+REGISTER_VK_STRUCT_ID(VkSemaphoreTypeCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO);
#undef REGISTER_VK_STRUCT_ID
