Merge pie-platform-release (PPRL.181105.017, history only) into master
Bug: 118454372
Change-Id: I329d78c043cc9c178b18d898417562b44a72b9fa
diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
new file mode 100644
index 0000000..86c10c8
--- /dev/null
+++ b/.vscode/c_cpp_properties.json
@@ -0,0 +1,27 @@
+{
+ "configurations": [
+ {
+ "name": "Mac",
+ "includePath": [
+ "${workspaceFolder}/**",
+ "${workspaceFolder}/external/qemu/android/android-emugl/guest",
+ "${workspaceFolder}/device/generic/goldfish-opengl/system/OpenglSystemCommon",
+ "${workspaceFolder}/device/generic/goldfish-opengl/shared/OpenglCodecCommon"
+ ],
+ "defines": [
+ "HOST_BUILD",
+ "GOLDFISH_VULKAN"
+ ],
+ "macFrameworkPath": [
+ "/System/Library/Frameworks",
+ "/Library/Frameworks"
+ ],
+ "compilerPath": "/usr/bin/clang",
+ "cStandard": "c11",
+ "cppStandard": "c++14",
+ "intelliSenseMode": "clang-x64",
+ "configurationProvider": "vector-of-bool.cmake-tools"
+ }
+ ],
+ "version": 4
+}
\ No newline at end of file
diff --git a/Android.mk b/Android.mk
index d598d71..9235b63 100644
--- a/Android.mk
+++ b/Android.mk
@@ -7,22 +7,71 @@
# Also define BUILD_EMULATOR_OPENGL_DRIVER to 'true' to build the gralloc
# stuff as well.
#
-ifeq (true,$(BUILD_EMULATOR_OPENGL))
-
# Top-level for all modules
-EMUGL_PATH := $(call my-dir)
+GOLDFISH_OPENGL_PATH := $(call my-dir)
+
+# There are two kinds of builds for goldfish-opengl:
+# 1. The standard guest build, denoted by BUILD_EMULATOR_OPENGL
+# 2. The host-side build, denoted by GOLDFISH_OPENGL_BUILD_FOR_HOST
+#
+# Variable controlling whether the build for goldfish-opengl
+# libraries (including their Android.mk's) should be triggered.
+GOLDFISH_OPENGL_SHOULD_BUILD := false
+
+# In the host build, some libraries have name collisions with
+# other libraries, so we have this variable here to control
+# adding a suffix to the names of libraries. Should be blank
+# for the guest build.
+GOLDFISH_OPENGL_LIB_SUFFIX :=
# Directory containing common headers used by several modules
# This is always set to a module's LOCAL_C_INCLUDES
# See the definition of emugl-begin-module in common.mk
-#
-EMUGL_COMMON_INCLUDES := $(EMUGL_PATH)/host/include/libOpenglRender $(EMUGL_PATH)/system/include
+EMUGL_COMMON_INCLUDES := $(GOLDFISH_OPENGL_PATH)/host/include/libOpenglRender $(GOLDFISH_OPENGL_PATH)/system/include
# common cflags used by several modules
# This is always set to a module's LOCAL_CFLAGS
# See the definition of emugl-begin-module in common.mk
-#
-EMUGL_COMMON_CFLAGS := -DWITH_GLES2 -DPLATFORM_SDK_VERSION=$(PLATFORM_SDK_VERSION)
+EMUGL_COMMON_CFLAGS := -DWITH_GLES2
+
+# Whether or not to build the Vulkan library.
+BUILD_EMULATOR_VULKAN := false
+
+# Host build
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+GOLDFISH_OPENGL_SHOULD_BUILD := true
+GOLDFISH_OPENGL_LIB_SUFFIX := _host
+
+BUILD_EMULATOR_VULKAN := true
+
+# Set modern defaults for the codename, version, etc.
+PLATFORM_VERSION_CODENAME:=Q
+PLATFORM_SDK_VERSION:=29
+IS_AT_LEAST_OPD1:=true
+
+# The host-side Android framework implementation
+HOST_EMUGL_PATH := $(GOLDFISH_OPENGL_PATH)/../../../external/qemu/android/android-emugl
+EMUGL_COMMON_INCLUDES += $(HOST_EMUGL_PATH)/guest
+
+EMUGL_COMMON_CFLAGS += \
+ -DPLATFORM_SDK_VERSION=29 \
+ -DGOLDFISH_HIDL_GRALLOC \
+ -DEMULATOR_OPENGL_POST_O=1 \
+ -DHOST_BUILD \
+ -DANDROID \
+ -DGL_GLEXT_PROTOTYPES \
+ -fvisibility=default \
+ -DPAGE_SIZE=4096 \
+ -DGOLDFISH_VULKAN \
+
+endif # GOLDFISH_OPENGL_BUILD_FOR_HOST
+
+ifeq (true,$(BUILD_EMULATOR_OPENGL)) # Guest build
+
+GOLDFISH_OPENGL_SHOULD_BUILD := true
+
+EMUGL_COMMON_CFLAGS += -DPLATFORM_SDK_VERSION=$(PLATFORM_SDK_VERSION)
ifeq (O, $(PLATFORM_VERSION_CODENAME))
EMUGL_COMMON_CFLAGS += -DGOLDFISH_HIDL_GRALLOC
@@ -49,15 +98,24 @@
EMUGL_COMMON_CFLAGS += -DALOGV=LOGV
endif
-# Uncomment the following line if you want to enable debug traces
-# in the GLES emulation libraries.
-# EMUGL_COMMON_CFLAGS += -DEMUGL_DEBUG=1
+ifeq ($(shell test $(PLATFORM_SDK_VERSION) -gt 27 && echo isApi28OrHigher),isApi28OrHigher)
+ BUILD_EMULATOR_VULKAN := true
+ EMUGL_COMMON_CFLAGS += -DGOLDFISH_VULKAN
+endif
# Include common definitions used by all the modules included later
# in this build file. This contains the definition of all useful
# emugl-xxxx functions.
#
-include $(EMUGL_PATH)/common.mk
+include $(GOLDFISH_OPENGL_PATH)/common.mk
+
+endif # BUILD_EMULATOR_OPENGL (guest build)
+
+ifeq (true,$(GOLDFISH_OPENGL_SHOULD_BUILD))
+
+# Uncomment the following line if you want to enable debug traces
+# in the GLES emulation libraries.
+# EMUGL_COMMON_CFLAGS += -DEMUGL_DEBUG=1
# IMPORTANT: ORDER IS CRUCIAL HERE
#
@@ -71,20 +129,35 @@
# Note that the build system will complain if you try to import a
# module that hasn't been declared yet anyway.
#
+include $(GOLDFISH_OPENGL_PATH)/shared/OpenglCodecCommon/Android.mk
-include $(EMUGL_PATH)/shared/OpenglCodecCommon/Android.mk
+# Encoder shared libraries
+include $(GOLDFISH_OPENGL_PATH)/system/GLESv1_enc/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/GLESv2_enc/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/renderControl_enc/Android.mk
-# System static libraries
-include $(EMUGL_PATH)/system/GLESv1_enc/Android.mk
-include $(EMUGL_PATH)/system/GLESv2_enc/Android.mk
-include $(EMUGL_PATH)/system/renderControl_enc/Android.mk
-include $(EMUGL_PATH)/system/OpenglSystemCommon/Android.mk
+ifeq (true,$(BUILD_EMULATOR_VULKAN)) # Vulkan libs
+ include $(GOLDFISH_OPENGL_PATH)/android-emu/Android.mk
+ include $(GOLDFISH_OPENGL_PATH)/system/vulkan_enc/Android.mk
+endif
+
+include $(GOLDFISH_OPENGL_PATH)/system/OpenglSystemCommon/Android.mk
# System shared libraries
-include $(EMUGL_PATH)/system/GLESv1/Android.mk
-include $(EMUGL_PATH)/system/GLESv2/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/GLESv1/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/GLESv2/Android.mk
-include $(EMUGL_PATH)/system/gralloc/Android.mk
-include $(EMUGL_PATH)/system/egl/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/system/gralloc/Android.mk
-endif # BUILD_EMULATOR_OPENGL == true
+include $(GOLDFISH_OPENGL_PATH)/system/egl/Android.mk
+
+ifeq (true,$(BUILD_EMULATOR_VULKAN)) # Vulkan libs
+ include $(GOLDFISH_OPENGL_PATH)/system/vulkan/Android.mk
+endif
+
+ifeq ($(shell test $(PLATFORM_SDK_VERSION) -gt 28 -o $(IS_AT_LEAST_QPR1) = true && echo isApi29OrHigher),isApi29OrHigher)
+ # HWC2 enabled after P
+ include $(GOLDFISH_OPENGL_PATH)/system/hwc2/Android.mk
+endif
+
+endif
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..ac15aad
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,17 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+set(GOLDFISH_DEVICE_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/./Android.mk" "8a354859d6be293140931db80edcbaf2c4db30118482356373f9ed2c92059806")
+add_subdirectory(shared/OpenglCodecCommon)
+add_subdirectory(system/GLESv1_enc)
+add_subdirectory(system/GLESv2_enc)
+add_subdirectory(system/renderControl_enc)
+add_subdirectory(android-emu)
+add_subdirectory(system/vulkan_enc)
+add_subdirectory(system/OpenglSystemCommon)
+add_subdirectory(system/GLESv1)
+add_subdirectory(system/GLESv2)
+add_subdirectory(system/gralloc)
+add_subdirectory(system/egl)
+add_subdirectory(system/vulkan)
\ No newline at end of file
diff --git a/GNUmakefile b/GNUmakefile
new file mode 100644
index 0000000..0610f29
--- /dev/null
+++ b/GNUmakefile
@@ -0,0 +1,60 @@
+# 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.
+#
+
+# Check that we have at least GNU Make 3.81
+# We do this by detecting whether 'lastword' is supported
+#
+MAKE_TEST := $(lastword a b c d e f)
+ifneq ($(MAKE_TEST),f)
+ $(error,This build system requires GNU Make 3.81 or higher to run !)
+endif
+
+# Find the source installation path, should be this file's location.
+_BUILD_ROOT := $(dir $(lastword $(MAKEFILE_LIST)))
+_BUILD_ROOT := $(_BUILD_ROOT:%/=%)
+
+# Complain if the path contains spaces
+ifneq ($(words $(_BUILD_ROOT)),1)
+ $(info,The source installation path contains spaces: '$(_BUILD_ROOT)')
+ $(error,Please fix the problem by reinstalling to a different location.)
+endif
+
+# We are going to generate a JSON representation from the build
+GOLDFISH_OPENGL_BUILD_FOR_HOST := true
+CMAKE_GENERATE := true
+_BUILD_CORE_DIR := ../../../external/qemu/android/build
+
+# We need the emulator's android makefile defs, so we can understand
+# the makefiles.
+include $(_BUILD_CORE_DIR)/emulator/definitions.make
+
+# We need the ability to dump json.
+include $(_BUILD_ROOT)/json-dump.mk
+
+# And we are going to build like we are an emulator host.
+include $(_BUILD_ROOT)/common.mk
+include $(_BUILD_ROOT)/Android.mk
+
+JSON_FILE := /tmp/build.json
+JSON_DUMP := [ "" $(JSON_DUMP) ]
+
+# And we are going to transform our generated json list into a set of
+# cmake files.
+
+# This is the first target, so also the default target
+cmake:
+ @rm -f $(JSON_FILE)
+ $(call write-to-file,$(JSON_FILE),30,$(JSON_DUMP))
+ $(hide) python cmake_transform.py -i $(JSON_FILE) -c $(JSON_FILE) -o ${_BUILD_ROOT}
\ No newline at end of file
diff --git a/android-emu/Android.mk b/android-emu/Android.mk
new file mode 100644
index 0000000..0e02fc1
--- /dev/null
+++ b/android-emu/Android.mk
@@ -0,0 +1,22 @@
+LOCAL_PATH := $(call my-dir)
+
+$(call emugl-begin-static-library,libandroidemu)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
+$(call emugl-export,SHARED_LIBRARIES,libcutils libutils liblog)
+
+LOCAL_CFLAGS += \
+ -DLOG_TAG=\"androidemu\" \
+ -Wno-missing-field-initializers \
+ -fvisibility=default \
+ -fstrict-aliasing \
+
+LOCAL_SRC_FILES := \
+ android/base/AlignedBuf.cpp \
+ android/base/files/MemStream.cpp \
+ android/base/files/Stream.cpp \
+ android/base/files/StreamSerializing.cpp \
+ android/base/Pool.cpp \
+ android/base/StringFormat.cpp \
+ android/utils/debug.c \
+
+$(call emugl-end-module)
diff --git a/android-emu/CMakeLists.txt b/android-emu/CMakeLists.txt
new file mode 100644
index 0000000..9e3218d
--- /dev/null
+++ b/android-emu/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/android-emu/Android.mk" "4b9cd7741f05b6dd1384a3dbc317d971365ed9c96ee19f42c1dcc075a2df10ba")
+set(androidemu_src android/base/AlignedBuf.cpp android/base/files/MemStream.cpp android/base/files/Stream.cpp android/base/files/StreamSerializing.cpp android/base/Pool.cpp android/base/StringFormat.cpp android/utils/debug.c)
+android_add_library(androidemu)
+target_include_directories(androidemu PRIVATE ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(androidemu PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"androidemu\"")
+target_compile_options(androidemu PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers" "-fstrict-aliasing")
+target_link_libraries(androidemu PRIVATE cutils utils log OpenglCodecCommon_host android-emu-shared)
\ No newline at end of file
diff --git a/android-emu/android/base/AlignedBuf.cpp b/android-emu/android/base/AlignedBuf.cpp
new file mode 100644
index 0000000..a1bc6f3
--- /dev/null
+++ b/android-emu/android/base/AlignedBuf.cpp
@@ -0,0 +1,45 @@
+// 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 "AlignedBuf.h"
+
+namespace android {
+
+// Convenience function for aligned malloc across platforms
+void* aligned_buf_alloc(size_t align, size_t size) {
+ size_t actualAlign = std::max(align, sizeof(void*));
+#ifdef _WIN32
+ void* res = _aligned_malloc(size, actualAlign);
+ if (!res) {
+ abort();
+ }
+ return res;
+#else
+ void* res;
+ if (posix_memalign(&res, actualAlign, size)) {
+ abort();
+ }
+ return res;
+#endif
+}
+
+void aligned_buf_free(void* buf) {
+#ifdef _WIN32
+ _aligned_free(buf);
+#else
+ free(buf);
+#endif
+}
+
+} // namespace android
\ No newline at end of file
diff --git a/android-emu/android/base/AlignedBuf.h b/android-emu/android/base/AlignedBuf.h
new file mode 100644
index 0000000..fc74e32
--- /dev/null
+++ b/android-emu/android/base/AlignedBuf.h
@@ -0,0 +1,149 @@
+// Copyright 2018 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/Compiler.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cinttypes>
+#include <cstdlib>
+#include <cstring>
+#include <type_traits>
+#include <vector>
+
+#include <stdio.h>
+
+#ifdef _WIN32
+#include <malloc.h>
+#endif
+
+namespace android {
+
+template <class T, size_t align>
+class AlignedBuf {
+public:
+ explicit AlignedBuf(size_t size) {
+ static_assert(align && ((align & (align - 1)) == 0),
+ "AlignedBuf only supports power-of-2 aligments.");
+ resizeImpl(size);
+ }
+
+ AlignedBuf(const AlignedBuf& other) : AlignedBuf(other.mSize) {
+ if (other.mBuffer) { // could have got moved out
+ std::copy(other.mBuffer, other.mBuffer + other.mSize, mBuffer);
+ }
+ }
+
+ AlignedBuf& operator=(const AlignedBuf& other) {
+ if (this != &other) {
+ AlignedBuf tmp(other);
+ *this = std::move(tmp);
+ }
+ return *this;
+ }
+
+ AlignedBuf(AlignedBuf&& other) { *this = std::move(other); }
+
+ AlignedBuf& operator=(AlignedBuf&& other) {
+ mBuffer = other.mBuffer;
+ mSize = other.mSize;
+
+ other.mBuffer = nullptr;
+ other.mSize = 0;
+
+ return *this;
+ }
+
+ ~AlignedBuf() { if (mBuffer) freeImpl(mBuffer); } // account for getting moved out
+
+ void resize(size_t newSize) {
+#if (defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 4) || \
+ defined(__OLD_STD_VERSION__)
+ // Older g++ doesn't support std::is_trivially_copyable.
+ constexpr bool triviallyCopyable =
+ std::has_trivial_copy_constructor<T>::value;
+#else
+ constexpr bool triviallyCopyable = std::is_trivially_copyable<T>::value;
+#endif
+ static_assert(triviallyCopyable,
+ "AlignedBuf can only resize trivially copyable values");
+
+ resizeImpl(newSize);
+ }
+
+ size_t size() const { return mSize; }
+
+ T* data() { return mBuffer; }
+
+ T& operator[](size_t index) { return mBuffer[index]; }
+
+ const T& operator[](size_t index) const { return mBuffer[index]; }
+
+ bool operator==(const AlignedBuf& other) const {
+ return 0 == std::memcmp(mBuffer, other.mBuffer, sizeof(T) * std::min(mSize, other.mSize));
+ }
+
+private:
+
+ void resizeImpl(size_t newSize) {
+ if (newSize) {
+ size_t pad = std::max(align, sizeof(T));
+ size_t keepSize = std::min(newSize, mSize);
+ size_t newSizeBytes = ((align - 1 + newSize * sizeof(T) + pad) / align) * align;
+
+ std::vector<T> temp(mBuffer, mBuffer + keepSize);
+ mBuffer = static_cast<T*>(reallocImpl(mBuffer, newSizeBytes));
+ std::copy(temp.data(), temp.data() + keepSize, mBuffer);
+ } else {
+ if (mBuffer) freeImpl(mBuffer);
+ mBuffer = nullptr;
+ }
+
+ mSize = newSize;
+ }
+
+ void* reallocImpl(void* oldPtr, size_t sizeBytes) {
+ if (oldPtr) { freeImpl(oldPtr); }
+ // Platform aligned malloc might not behave right
+ // if we give it an alignemnt value smaller than sizeof(void*).
+ size_t actualAlign = std::max(align, sizeof(void*));
+#ifdef _WIN32
+ return _aligned_malloc(sizeBytes, actualAlign);
+#else
+ void* res;
+ if (posix_memalign(&res, actualAlign, sizeBytes)) {
+ fprintf(stderr, "%s: failed to alloc aligned memory\n", __func__);
+ abort();
+ }
+ return res;
+#endif
+ }
+
+ void freeImpl(void* ptr) {
+#ifdef _WIN32
+ _aligned_free(ptr);
+#else
+ free(ptr);
+#endif
+
+ }
+
+ T* mBuffer = nullptr;
+ size_t mSize = 0;
+};
+
+// Convenience function for aligned malloc across platforms
+void* aligned_buf_alloc(size_t align, size_t size);
+void aligned_buf_free(void* buf);
+
+} // namespace android
diff --git a/android-emu/android/base/Compiler.h b/android-emu/android/base/Compiler.h
new file mode 100644
index 0000000..ddfd992
--- /dev/null
+++ b/android-emu/android/base/Compiler.h
@@ -0,0 +1,39 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+// Use this inside a class declaration to ensure that the corresponding objects
+// cannot be copy-constructed or assigned. For example:
+//
+// class Foo {
+// ....
+// DISALLOW_COPY_AND_ASSIGN(Foo)
+// ....
+// };
+//
+// Note: this macro is sometimes defined in 3rd-party libs, so let's check first
+#ifndef DISALLOW_COPY_AND_ASSIGN
+
+#define DISALLOW_COPY_AND_ASSIGN(T) \
+ T(const T& other) = delete; \
+ T& operator=(const T& other) = delete
+
+#endif
+
+#ifndef DISALLOW_COPY_ASSIGN_AND_MOVE
+
+#define DISALLOW_COPY_ASSIGN_AND_MOVE(T) \
+ DISALLOW_COPY_AND_ASSIGN(T); \
+ T(T&&) = delete; \
+ T& operator=(T&&) = delete
+
+#endif
diff --git a/android-emu/android/base/Optional.h b/android-emu/android/base/Optional.h
new file mode 100644
index 0000000..c599828
--- /dev/null
+++ b/android-emu/android/base/Optional.h
@@ -0,0 +1,544 @@
+// Copyright 2015-2016 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/TypeTraits.h"
+
+#include <log/log.h>
+
+#include <cassert>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+#include <cstddef>
+
+// Optional<T> - a template class to store an optional value of type T.
+//
+// Usage examples:
+//
+// Initialization and construction:
+// Optional<Foo> foo; // |foo| doesn't contain a value.
+// Optional<Foo> foo(Foo(10)); // |foo| contains a copy-constructed value.
+// Optional<Foo> foo2(foo); // |foo2| contains a copy of |foo|'s value.
+// Optional<Foo> foo3(std::move(foo2)); // Guess what?
+//
+// Assignment:
+// Foo foo_value(0);
+// Optional<Foo> foo; // |foo| is empty.
+// Optional<Foo> foo2; // |foo2| is empty.
+// foo2 = foo; // |foo2| is still empty.
+// foo = foo_value; // set value of |foo| to a copy of |foo_value|
+// foo = std::move(foo_value); // move |foo_value| into |foo|.
+// foo2 = foo; // now |foo2| has a copy of |foo|'s value.
+// foo = kNullopt; // unset |foo|, it has no value.
+//
+// Checking and accessing value:
+// if (foo) {
+// // |foo| has a value.
+// doStuff(*foo); // |*foo| is the value inside |foo|.
+// foo->callMethod(); // Same as (*foo).callMethod().
+// } else {
+// // |foo| is empty.
+// }
+//
+// foo.value() // Same as *foo
+// foo.valueOr(<default>) // Return <default> is |foo| has no value.
+//
+// In-place construction:
+//
+// Optional<Foo> foo; // |foo| is empty.
+// foo.emplace(20); // |foo| now contains a value constructed as Foo(20)
+//
+// Optional<Foo> foo(kInplace, 20); // |foo| is initialized with a value
+// // that is constructed in-place as
+// // Foo(20).
+//
+// return makeOptional<Foo>(20); // Takes Foo constructor arguments
+// // directly.
+//
+// Returning values:
+//
+// Optional<Foo> myFunc(...) {
+// if (someCondition) {
+// return Foo(10); // call Optional<Foo>(Foo&) constructor.
+// } else {
+// return {}; // call Optional<Foo>() constructor, which
+// // builds an empty value.
+// }
+// }
+//
+// Memory layout:
+// Optional<Foo> is equivalent to:
+//
+// struct {
+// bool flag;
+// Foo value;
+// };
+//
+// in terms of memory layout. This means it *doubles* the size of integral
+// types. Also:
+//
+// - Optional<Foo> can be constructed from anything that constructs a Foo.
+//
+// - Same with Optional<Foo>(kInplace, Args...) where Args... matches any
+// arguments that can be passed to a Foo constructor.
+//
+// - Comparison operators are provided. Beware: an empty Optional<Foo>
+// is always smaller than any Foo value.
+
+namespace android {
+namespace base {
+
+namespace details {
+
+// Base classes to reduce the number of instantiations of the Optional's
+// internal members.
+class OptionalFlagBase {
+public:
+ void setConstructed(bool constructed) { mConstructed = constructed; }
+ constexpr bool constructed() const { return mConstructed; }
+ constexpr operator bool() const { return constructed(); }
+ bool hasValue() const { return constructed(); }
+
+ constexpr OptionalFlagBase(bool constructed = false)
+ : mConstructed(constructed) {}
+
+private:
+ bool mConstructed = false;
+};
+
+template <size_t Size, size_t Align>
+class OptionalStorageBase {
+protected:
+ using StoreT = typename std::aligned_storage<Size, Align>::type;
+ StoreT mStorage = {};
+};
+
+} // namespace details
+
+// A tag type for empty optional construction
+struct NulloptT {
+ constexpr explicit NulloptT(int) {}
+};
+
+// A tag type for inplace value construction
+struct InplaceT {
+ constexpr explicit InplaceT(int) {}
+};
+
+// Tag values for null optional and inplace construction
+constexpr NulloptT kNullopt{1};
+constexpr InplaceT kInplace{1};
+
+// Forward declaration for an early use
+template <class T>
+class Optional;
+
+// A type trait for checking if a type is an optional instantiation
+// Note: if you want to refer to the template name inside the template,
+// you need to declare this alias outside of it - because the
+// class name inside of the template stands for an instantiated template
+// E.g, for template <T> class Foo if you say 'Foo' inside the class, it
+// actually means Foo<T>;
+template <class U>
+using is_any_optional =
+ is_template_instantiation_of<typename std::decay<U>::type, Optional>;
+
+template <class T>
+class Optional
+ : private details::OptionalFlagBase,
+ private details::OptionalStorageBase<sizeof(T),
+ std::alignment_of<T>::value> {
+ // make sure all optionals are buddies - this is needed to implement
+ // conversion from optionals of other types
+ template <class U>
+ friend class Optional;
+
+ template <class U>
+ using self = Optional<U>;
+
+ using base_flag = details::OptionalFlagBase;
+ using base_storage =
+ details::OptionalStorageBase<sizeof(T),
+ std::alignment_of<T>::value>;
+
+public:
+ // std::optional will have this, so let's provide it
+ using value_type = T;
+
+ // make sure we forbid some Optional instantiations where things may get
+ // really messy
+ static_assert(!std::is_same<typename std::decay<T>::type, NulloptT>::value,
+ "Optional of NulloptT is not allowed");
+ static_assert(!std::is_same<typename std::decay<T>::type, InplaceT>::value,
+ "Optional of InplaceT is not allowed");
+ static_assert(!std::is_reference<T>::value,
+ "Optional references are not allowed: use a pointer instead");
+
+ // constructors
+ constexpr Optional() {}
+ constexpr Optional(NulloptT) {}
+
+ Optional(const Optional& other) : base_flag(other.constructed()) {
+ if (this->constructed()) {
+ new (&get()) T(other.get());
+ }
+ }
+ Optional(Optional&& other) : base_flag(other.constructed()) {
+ if (this->constructed()) {
+ new (&get()) T(std::move(other.get()));
+ }
+ }
+
+ // Conversion constructor from optional of similar type
+ template <class U,
+ class = enable_if_c<!is_any_optional<U>::value &&
+ std::is_constructible<T, U>::value>>
+ Optional(const Optional<U>& other) : base_flag(other.constructed()) {
+ if (this->constructed()) {
+ new (&get()) T(other.get());
+ }
+ }
+
+ // Move-conversion constructor
+ template <class U,
+ class = enable_if_c<!is_any_optional<U>::value &&
+ std::is_constructible<T, U>::value>>
+ Optional(Optional<U>&& other) : base_flag(other.constructed()) {
+ if (this->constructed()) {
+ new (&get()) T(std::move(other.get()));
+ }
+ }
+
+ // Construction from a raw value
+ Optional(const T& value) : base_flag(true) { new (&get()) T(value); }
+ // Move construction from a raw value
+ Optional(T&& value) : base_flag(true) { new (&get()) T(std::move(value)); }
+
+ // Inplace construction from a list of |T|'s ctor arguments
+ template <class... Args>
+ Optional(InplaceT, Args&&... args) : base_flag(true) {
+ new (&get()) T(std::forward<Args>(args)...);
+ }
+
+ // Inplace construction from an initializer list passed into |T|'s ctor
+ template <class U,
+ class = enable_if<
+ std::is_constructible<T, std::initializer_list<U>>>>
+ Optional(InplaceT, std::initializer_list<U> il) : base_flag(true) {
+ new (&get()) T(il);
+ }
+
+ // direct assignment
+ Optional& operator=(const Optional& other) {
+ if (&other == this) {
+ return *this;
+ }
+
+ if (this->constructed()) {
+ if (other.constructed()) {
+ get() = other.get();
+ } else {
+ destruct();
+ this->setConstructed(false);
+ }
+ } else {
+ if (other.constructed()) {
+ new (&get()) T(other.get());
+ this->setConstructed(true);
+ } else {
+ ; // we're good
+ }
+ }
+ return *this;
+ }
+
+ // move assignment
+ Optional& operator=(Optional&& other) {
+ if (this->constructed()) {
+ if (other.constructed()) {
+ get() = std::move(other.get());
+ } else {
+ destruct();
+ this->setConstructed(false);
+ }
+ } else {
+ if (other.constructed()) {
+ new (&get()) T(std::move(other.get()));
+ this->setConstructed(true);
+ } else {
+ ; // we're good
+ }
+ }
+ return *this;
+ }
+
+ // conversion assignment
+ template <class U,
+ class = enable_if_convertible<typename std::decay<U>::type, T>>
+ Optional& operator=(const Optional<U>& other) {
+ if (this->constructed()) {
+ if (other.constructed()) {
+ get() = other.get();
+ } else {
+ destruct();
+ this->setConstructed(false);
+ }
+ } else {
+ if (other.constructed()) {
+ new (&get()) T(other.get());
+ this->setConstructed(true);
+ } else {
+ ; // we're good
+ }
+ }
+ return *this;
+ }
+
+ // conversion move assignment
+ template <class U,
+ class = enable_if_convertible<typename std::decay<U>::type, T>>
+ Optional& operator=(Optional<U>&& other) {
+ if (this->constructed()) {
+ if (other.constructed()) {
+ get() = std::move(other.get());
+ } else {
+ destruct();
+ this->setConstructed(false);
+ }
+ } else {
+ if (other.constructed()) {
+ new (&get()) T(std::move(other.get()));
+ this->setConstructed(true);
+ } else {
+ ; // we're good
+ }
+ }
+ return *this;
+ }
+
+ // the most complicated one: forwarding constructor for anything convertible
+ // to |T|, excluding the stuff implemented above explicitly
+ template <class U,
+ class = enable_if_c<
+ !is_any_optional<typename std::decay<U>::type>::value &&
+ std::is_convertible<typename std::decay<U>::type,
+ T>::value>>
+ Optional& operator=(U&& other) {
+ if (this->constructed()) {
+ get() = std::forward<U>(other);
+ } else {
+ new (&get()) T(std::forward<U>(other));
+ this->setConstructed(true);
+ }
+ return *this;
+ }
+
+ // Adopt value checkers from the parent
+ using base_flag::operator bool;
+ using base_flag::hasValue;
+
+ T& value() {
+ if (!constructed()) {
+ ALOGE("Optional not constructed");
+ abort();
+ }
+ return get();
+ }
+ constexpr const T& value() const {
+ if (!constructed()) {
+ ALOGE("Optional not constructed");
+ abort();
+ }
+ return get();
+ }
+
+ T* ptr() {
+ return this->constructed() ? &get() : nullptr;
+ }
+ constexpr const T* ptr() const {
+ return this->constructed() ? &get() : nullptr;
+ }
+
+ // Value getter with fallback
+ template <class U = T,
+ class = enable_if_convertible<typename std::decay<U>::type, T>>
+ constexpr T valueOr(U&& defaultValue) const {
+ return this->constructed() ? get() : std::move(defaultValue);
+ }
+
+ // Pointer-like operators
+ T& operator*() {
+ if (!constructed()) {
+ ALOGE("Optional not constructed");
+ abort();
+ }
+ return get();
+ }
+ constexpr const T& operator*() const {
+ if (!constructed()) {
+ ALOGE("Optional not constructed");
+ abort();
+ }
+ return get();
+ }
+
+ T* operator->() {
+ if (!constructed()) {
+ ALOGE("Optional not constructed");
+ abort();
+ }
+ return &get();
+ }
+ constexpr const T* operator->() const {
+ if (!constructed()) {
+ ALOGE("Optional not constructed");
+ abort();
+ }
+ return &get();
+ }
+
+ ~Optional() {
+ if (this->constructed()) {
+ destruct();
+ }
+ }
+
+ void clear() {
+ if (this->constructed()) {
+ destruct();
+ this->setConstructed(false);
+ }
+ }
+
+ template <class U,
+ class = enable_if_convertible<typename std::decay<U>::type, T>>
+ void reset(U&& u) {
+ *this = std::forward<U>(u);
+ }
+
+ // In-place construction with possible destruction of the old value
+ template <class... Args>
+ void emplace(Args&&... args) {
+ if (this->constructed()) {
+ destruct();
+ }
+ new (&get()) T(std::forward<Args>(args)...);
+ this->setConstructed(true);
+ }
+
+ // In-place construction with possible destruction of the old value
+ // initializer-list version
+ template <class U,
+ class = enable_if<
+ std::is_constructible<T, std::initializer_list<U>>>>
+ void emplace(std::initializer_list<U> il) {
+ if (this->constructed()) {
+ destruct();
+ }
+ new (&get()) T(il);
+ this->setConstructed(true);
+ }
+
+private:
+ // A helper function to convert the internal raw storage to T&
+ constexpr const T& get() const {
+ return *reinterpret_cast<const T*>(
+ reinterpret_cast<const char*>(&this->mStorage));
+ }
+
+ // Same thing, mutable
+ T& get() {
+ return const_cast<T&>(const_cast<const Optional*>(this)->get());
+ }
+
+ // Shortcut for a destructor call for the stored object
+ void destruct() { get().T::~T(); }
+};
+
+template <class T>
+Optional<typename std::decay<T>::type> makeOptional(T&& t) {
+ return Optional<typename std::decay<T>::type>(std::forward<T>(t));
+}
+
+template <class T, class... Args>
+Optional<typename std::decay<T>::type> makeOptional(Args&&... args) {
+ return Optional<typename std::decay<T>::type>(kInplace,
+ std::forward<Args>(args)...);
+}
+
+template <class T>
+bool operator==(const Optional<T>& l, const Optional<T>& r) {
+ return l.hasValue() ? r.hasValue() && *l == *r : !r.hasValue();
+}
+template <class T>
+bool operator==(const Optional<T>& l, NulloptT) {
+ return !l;
+}
+template <class T>
+bool operator==(NulloptT, const Optional<T>& r) {
+ return !r;
+}
+template <class T>
+bool operator==(const Optional<T>& l, const T& r) {
+ return bool(l) && *l == r;
+}
+template <class T>
+bool operator==(const T& l, const Optional<T>& r) {
+ return bool(r) && l == *r;
+}
+
+template <class T>
+bool operator!=(const Optional<T>& l, const Optional<T>& r) {
+ return !(l == r);
+}
+template <class T>
+bool operator!=(const Optional<T>& l, NulloptT) {
+ return bool(l);
+}
+template <class T>
+bool operator!=(NulloptT, const Optional<T>& r) {
+ return bool(r);
+}
+template <class T>
+bool operator!=(const Optional<T>& l, const T& r) {
+ return !l || !(*l == r);
+}
+template <class T>
+bool operator!=(const T& l, const Optional<T>& r) {
+ return !r || !(l == *r);
+}
+
+template <class T>
+bool operator<(const Optional<T>& l, const Optional<T>& r) {
+ return !r ? false : (!l ? true : *l < *r);
+}
+template <class T>
+bool operator<(const Optional<T>&, NulloptT) {
+ return false;
+}
+template <class T>
+bool operator<(NulloptT, const Optional<T>& r) {
+ return bool(r);
+}
+template <class T>
+bool operator<(const Optional<T>& l, const T& r) {
+ return !l || *l < r;
+}
+template <class T>
+bool operator<(const T& l, const Optional<T>& r) {
+ return bool(r) && l < *r;
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/Pool.cpp b/android-emu/android/base/Pool.cpp
new file mode 100644
index 0000000..6aa47b4
--- /dev/null
+++ b/android-emu/android/base/Pool.cpp
@@ -0,0 +1,440 @@
+// 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 "android/base/Pool.h"
+
+#include "android/base/AlignedBuf.h"
+
+#include <vector>
+
+#define DEBUG_POOL 0
+
+#if DEBUG_POOL
+
+#define D(fmt,...) fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__);
+
+#else
+
+#define D(fmt,...)
+
+#endif
+
+namespace android {
+namespace base {
+
+// A Pool consists of:
+// - Heaps one for each allocation size
+// A Heap consists of:
+// - Block(s) for servicing allocation requests with actual memory backing
+// A Block consists of:
+// - A buffer that is the memory backing
+// - Chunks that correspond to usable units of the allocation size
+//
+// Block implementation:
+//
+// We want to make it fast to alloc new chunks and to free existing chunks from
+// this block, while not having to invalidate all existing pointers when
+// allocating new objects.
+// I'm p sure by now there's no way to do that withtout
+// - significant pre allocation
+// - linked list of blocks
+//
+// So that means some block chain (hehehehe, pun v much intended)
+// implementation Wherein, each block has fast allocation of chunks
+// correponding tot he desired allocation size.
+//
+// Any low overhead scheme of that kind, like slab alloc or buddy alloc, is
+// fine. This one is based on:
+//
+// Ben Kenwright (b.kenwright@ncl.ac.uk): "Fast Efficient Fixed-Size Memory
+// Pool: No Loops and No Overhead" In COMPUTATION TOOLS 2012: The Third
+// International Conference on Computational Logics, Algebras, Programming,
+// Tools, and Benchmarking
+
+// Interval:
+// Make it easy to track all ranges involved so we know which free()
+// in which heap to use.
+// Assuming this doesn't grow too much past around 100 intervals
+// so we dont need to use fancy algorithms to key on it.
+struct Interval {
+ uintptr_t start;
+ uintptr_t end;
+};
+
+static size_t ilog2Floor(size_t n) {
+ size_t res = 0;
+ size_t test = 1;
+
+ while (test < n) {
+ test <<= 1;
+ ++res;
+ }
+
+ return res;
+}
+
+struct Block {
+ Block(size_t _chunkSize, size_t _numChunks) {
+ if (_chunkSize < sizeof(void*)) {
+ fprintf(
+ stderr,
+ "FATAL: Cannot allocate block with chunk size "
+ "less then %zu (wanted: %zu)!\n",
+ sizeof(void*),
+ _chunkSize);
+ abort();
+ }
+
+ chunkSize = _chunkSize;
+ chunkSizeLog2 = ilog2Floor(chunkSize);
+ numChunks = _numChunks;
+
+ D("chunk size %zu log2 %zu numChunks %zu",
+ chunkSize,
+ chunkSizeLog2,
+ numChunks);
+
+ sizeBytes = chunkSize * numChunks;
+
+ storage.resize(sizeBytes);
+ data = storage.data();
+
+ numFree = numChunks;
+ numAlloced = 0;
+ nextFree = (size_t*)data;
+ }
+
+ Interval getInterval() const {
+ uintptr_t start = (uintptr_t)data;
+ uintptr_t end = (uintptr_t)(data + sizeBytes);
+ return { start, end };
+ }
+
+ bool isFull() const { return numFree == 0; }
+
+ uint8_t* getPtr(size_t element) {
+ uint8_t* res =
+ data + (uintptr_t)chunkSize *
+ (uintptr_t)element;
+ D("got %p element %zu chunkSize %zu",
+ res, element, chunkSize);
+ return res;
+ }
+
+ size_t getElement(void* ptr) {
+ uintptr_t ptrVal = (uintptr_t)ptr;
+ ptrVal -= (uintptr_t)data;
+ return (size_t)(ptrVal >> chunkSizeLog2);
+ }
+
+ void* alloc() {
+ // Lazily constructs the index to the
+ // next unallocated chunk.
+ if (numAlloced < numChunks) {
+ size_t* nextUnallocPtr =
+ (size_t*)getPtr(numAlloced);
+
+ ++numAlloced;
+ *nextUnallocPtr = numAlloced;
+ }
+
+ // Returns the next free object,
+ // if there is space remaining.
+ void* res = nullptr;
+ if (numFree) {
+
+ D("alloc new ptr @ %p\n", nextFree);
+
+ res = (void*)nextFree;
+ --numFree;
+ if (numFree) {
+ // Update nextFree to _point_ at the index
+ // of the next free chunk.
+ D("store %zu in %p as next free chunk",
+ *nextFree,
+ getPtr(*nextFree));
+ nextFree = (size_t*)getPtr(*nextFree);
+ } else {
+ // Signal that there are no more
+ // chunks available.
+ nextFree = nullptr;
+ }
+ }
+
+ return res;
+ }
+
+ void free(void* toFree) {
+ size_t* toFreeIndexPtr = (size_t*)toFree;
+ if (nextFree) {
+ D("freeing %p: still have other chunks available.", toFree);
+ D("nextFree: %p (end: %p)", nextFree, getPtr(numChunks));
+ D("nextFreeElt: %zu\n", getElement(nextFree));
+ // If there is a chunk available,
+ // point the just-freed chunk to that.
+ *toFreeIndexPtr = getElement(nextFree);
+ } else {
+ D("freeing free %p: no other chunks available.", toFree);
+ // If there are no chunks available,
+ // point the just-freed chunk to past the end.
+ *(size_t*)toFree = numChunks;
+ }
+ nextFree = (size_t*)toFree;
+ D("set next free to %p", nextFree);
+ ++numFree;
+ }
+
+ // To free everything, just reset back to the initial state :p
+ void freeAll() {
+ numFree = numChunks;
+ numAlloced = 0;
+ nextFree = (size_t*)data;
+ }
+
+ Block* next = nullptr; // Unused for now
+
+ size_t chunkSize = 0;
+ size_t chunkSizeLog2 = 0;
+ size_t numChunks = 0;
+ size_t sizeBytes = 0;
+
+ AlignedBuf<uint8_t, 64> storage { 0 };
+ uint8_t* data = nullptr;
+
+ size_t numFree = 0;
+ size_t numAlloced = 0;
+
+ size_t* nextFree = 0;
+};
+
+// Straight passthrough to Block for now unless
+// we find it necessary to track more than |kMaxAllocs|
+// allocs per heap.
+class Heap {
+public:
+ Heap(size_t allocSize, size_t chunksPerSize) :
+ mBlock(allocSize, chunksPerSize) {
+ }
+
+ Interval getInterval() const {
+ return mBlock.getInterval();
+ }
+
+ bool isFull() const {
+ return mBlock.isFull();
+ }
+
+ void* alloc() {
+ return mBlock.alloc();
+ }
+
+ void free(void* ptr) {
+ mBlock.free(ptr);
+ }
+
+ void freeAll() {
+ mBlock.freeAll();
+ }
+
+private:
+ // Just one block for now
+ Block mBlock;
+};
+
+static size_t leastPowerof2(size_t n) {
+ size_t res = 1;
+ while (res < n) {
+ res <<= 1;
+ }
+ return res;
+}
+
+class Pool::Impl {
+public:
+ Impl(size_t minSize,
+ size_t maxSize,
+ size_t chunksPerSize) :
+ // Need to bump up min alloc size
+ // because Blocks use free space for bookkeeping
+ // purposes.
+ mMinAllocSize(std::max(sizeof(void*), minSize)),
+ // Compute mMinAllocLog2.
+ // mMinAllocLog2 stores
+ // the number of bits to shift
+ // in order to obtain the heap index
+ // corresponding to a desired allocation size.
+ mMinAllocLog2(ilog2Floor(mMinAllocSize)),
+ mMaxFastSize(maxSize),
+ mChunksPerSize(chunksPerSize) {
+
+ size_t numHeaps =
+ 1 + ilog2Floor(mMaxFastSize >> mMinAllocLog2);
+
+ for (size_t i = 0; i < numHeaps; i++) {
+
+ size_t allocSize = mMinAllocSize << i;
+
+ D("create heap for size %zu", allocSize);
+
+ Heap* newHeap = new Heap(allocSize, mChunksPerSize);
+
+ HeapInfo info = {
+ newHeap,
+ allocSize,
+ newHeap->getInterval(),
+ };
+
+ mHeapInfos.push_back(info);
+ }
+ }
+
+ ~Impl() {
+ for (auto& info : mHeapInfos) {
+ delete info.heap;
+ }
+ }
+
+ void* alloc(size_t wantedSize) {
+ if (wantedSize > mMaxFastSize) {
+ D("requested size %zu too large", wantedSize);
+ return nullptr;
+ }
+
+ size_t minAllocSizeNeeded =
+ std::max(mMinAllocSize, leastPowerof2(wantedSize));
+
+ size_t index =
+ ilog2Floor(minAllocSizeNeeded >> mMinAllocLog2);
+
+ D("wanted: %zu min serviceable: %zu heap index: %zu",
+ wantedSize, minAllocSizeNeeded, index);
+
+ auto heap = mHeapInfos[index].heap;
+
+ if (heap->isFull()) {
+ D("heap %zu is full", index);
+ return nullptr;
+ }
+
+ return heap->alloc();
+ }
+
+ bool free(void* ptr) {
+
+ D("for %p:", ptr);
+
+ uintptr_t ptrVal = (uintptr_t)ptr;
+
+ // Scan through linearly to find any matching
+ // interval. Interval information has been
+ // brought up to be stored directly in HeapInfo
+ // so this should be quite easy on the cache
+ // at least until a match is found.
+ for (auto& info : mHeapInfos) {
+ uintptr_t start = info.interval.start;
+ uintptr_t end = info.interval.end;
+
+ if (ptrVal >= start && ptrVal < end) {
+ D("found heap to free %p.", ptr)
+ info.heap->free(ptr);
+ return true;
+ }
+ }
+
+ D("%p not found in any heap.", ptr);
+ return false;
+ }
+
+ void freeAll() {
+ for (auto& info : mHeapInfos) {
+ info.heap->freeAll();
+ }
+ }
+
+private:
+ size_t mMinAllocSize;
+ size_t mMinAllocLog2;
+ size_t mMaxFastSize;
+ size_t mChunksPerSize;
+
+ // No need to get really complex if there are
+ // not that many heaps.
+ struct HeapInfo {
+ Heap* heap;
+ size_t allocSize;
+ Interval interval;
+ };
+
+ std::vector<HeapInfo> mHeapInfos;
+};
+
+Pool::Pool(size_t minSize,
+ size_t maxSize,
+ size_t mChunksPerSize) :
+ mImpl(new Pool::Impl(minSize,
+ maxSize,
+ mChunksPerSize)) {
+}
+
+Pool::~Pool() {
+ delete mImpl;
+
+ for (auto ptr : mFallbackPtrs) {
+ D("delete fallback ptr %p\n", ptr);
+ ::free(ptr);
+ }
+}
+
+// Fall back to normal alloc if it cannot be
+// serviced by the implementation.
+void* Pool::alloc(size_t wantedSize) {
+ void* ptr = mImpl->alloc(wantedSize);
+
+ if (ptr) return ptr;
+
+ D("Fallback to malloc");
+
+ ptr = ::malloc(wantedSize);
+
+ if (!ptr) {
+ D("Failed to service allocation for %zu bytes", wantedSize);
+ abort();
+ }
+
+ mFallbackPtrs.insert(ptr);
+
+ D("Fallback to malloc: got ptr %p", ptr);
+
+ return ptr;
+}
+
+// Fall back to normal free if it cannot be
+// serviced by the implementation.
+void Pool::free(void* ptr) {
+ if (mImpl->free(ptr)) return;
+
+ D("fallback to free for %p", ptr);
+ mFallbackPtrs.erase(ptr);
+ ::free(ptr);
+}
+
+void Pool::freeAll() {
+ mImpl->freeAll();
+ for (auto ptr : mFallbackPtrs) {
+ ::free(ptr);
+ }
+ mFallbackPtrs.clear();
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/Pool.h b/android-emu/android/base/Pool.h
new file mode 100644
index 0000000..bce2cc1
--- /dev/null
+++ b/android-emu/android/base/Pool.h
@@ -0,0 +1,95 @@
+// 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.
+#pragma once
+
+#include <unordered_set>
+
+#include <inttypes.h>
+#include <stddef.h>
+#include <string.h>
+
+namespace android {
+namespace base {
+
+// 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 {
+public:
+ // minSize/maxSize: the target range of sizes for which we want to
+ // make allocations fast. the greater the range, the more space
+ // traded off.
+ // chunksPerSize: the target maximum number of live objects of
+ // each size that are expected. the higher it is, the more space
+ // traded off.
+ //
+ // Rough space cost formula:
+ // O(chunksPerSize * log2(maxSize / minSize) * maxSize)
+ Pool(size_t minSize = 8,
+ size_t maxSize = 4096,
+ size_t chunksPerSize = 256);
+
+ // All memory allocated by this pool
+ // is automatically deleted when the pool
+ // is deconstructed.
+ ~Pool();
+
+ void* alloc(size_t wantedSize);
+ 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;
+
+ std::unordered_set<void*> mFallbackPtrs;
+};
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/StringFormat.cpp b/android-emu/android/base/StringFormat.cpp
new file mode 100644
index 0000000..73a0e7a
--- /dev/null
+++ b/android-emu/android/base/StringFormat.cpp
@@ -0,0 +1,81 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#include "android/base/StringFormat.h"
+
+#include <stdio.h>
+
+namespace android {
+namespace base {
+
+std::string StringFormatRaw(const char* format, ...) {
+ va_list args;
+ va_start(args, format);
+ auto result = StringFormatWithArgs(format, args);
+ va_end(args);
+ return result;
+}
+
+std::string StringFormatWithArgs(const char* format, va_list args) {
+ std::string result;
+ StringAppendFormatWithArgs(&result, format, args);
+ return result;
+}
+
+void StringAppendFormatRaw(std::string* string, const char* format, ...) {
+ va_list args;
+ va_start(args, format);
+ StringAppendFormatWithArgs(string, format, args);
+ va_end(args);
+}
+
+void StringAppendFormatWithArgs(std::string* string,
+ const char* format,
+ va_list args) {
+ size_t cur_size = string->size();
+ size_t extra = 0;
+ for (;;) {
+ va_list args2;
+ va_copy(args2, args);
+ int ret = vsnprintf(&(*string)[cur_size], extra, format, args2);
+ va_end(args2);
+
+ if (ret == 0) {
+ // Nothing to do here.
+ break;
+ }
+
+ if (ret > 0) {
+ size_t ret_sz = static_cast<size_t>(ret);
+ if (extra == 0) {
+ // First pass, resize the string and try again.
+ extra = ret_sz + 1;
+ string->resize(cur_size + extra);
+ continue;
+ }
+ if (ret_sz < extra) {
+ // Second pass or later, success!
+ string->resize(cur_size + ret_sz);
+ return;
+ }
+ }
+
+ // NOTE: The MSVCRT.DLL implementation of snprintf() is broken and
+ // will return -1 in case of truncation. This code path is taken
+ // when this happens, or when |ret_sz| is equal or larger than
+ // |extra|. Grow the buffer to allow for more room, then try again.
+ extra += (extra >> 1) + 32;
+ string->resize(cur_size + extra);
+ }
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/StringFormat.h b/android-emu/android/base/StringFormat.h
new file mode 100644
index 0000000..184ee5f
--- /dev/null
+++ b/android-emu/android/base/StringFormat.h
@@ -0,0 +1,80 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/StringView.h"
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <stdarg.h>
+
+namespace android {
+namespace base {
+
+// Create a new string instance that contains the printf-style formatted
+// output from |format| and potentially any following arguments.
+std::string StringFormatRaw(const char* format, ...);
+
+// A variant of StringFormat() which uses a va_list to list formatting
+// parameters instead.
+std::string StringFormatWithArgs(const char* format, va_list args);
+
+// Appends a formatted string at the end of an existing string.
+// |string| is the target string instance, |format| the format string,
+// followed by any formatting parameters. This is more efficient than
+// appending the result of StringFormat(format,...) to |*string| directly.
+void StringAppendFormatRaw(std::string* string, const char* format, ...);
+
+// A variant of StringAppendFormat() that takes a va_list to list
+// formatting parameters.
+void StringAppendFormatWithArgs(std::string* string,
+ const char* format,
+ va_list args);
+
+// unpackFormatArg() is a set of overloaded functions needed to unpack
+// an argument of the formatting list to a POD value which can be passed
+// into the sprintf()-like C function
+
+// Anything which can be used to construct a string goes here and unpacks into
+// a const char*
+inline const char* unpackFormatArg(const std::string& str) {
+ return str.c_str();
+}
+
+// Forward all PODs as-is
+template <class T>
+constexpr T&& unpackFormatArg(T&& t,
+ typename std::enable_if<
+ std::is_pod<typename std::decay<T>::type>::value
+ >::type* = nullptr) {
+ return std::forward<T>(t);
+}
+
+// These templated versions of StringFormat*() allow one to pass all kinds of
+// string objects into the argument list
+template <class... Args>
+std::string StringFormat(const char* format, Args&&... args) {
+ return StringFormatRaw(format, unpackFormatArg(std::forward<Args>(args))...);
+}
+
+template <class... Args>
+void StringAppendFormat(std::string* string,
+ const char* format,
+ Args&&... args) {
+ StringAppendFormatRaw(string, format,
+ unpackFormatArg(std::forward<Args>(args))...);
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/StringView.h b/android-emu/android/base/StringView.h
new file mode 100644
index 0000000..f97ac5f
--- /dev/null
+++ b/android-emu/android/base/StringView.h
@@ -0,0 +1,295 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/Optional.h"
+#include "android/base/TypeTraits.h"
+
+#include <algorithm>
+#include <cstring>
+#include <string>
+
+namespace android {
+namespace base {
+
+// A StringView is a simple (address, size) pair that points to an
+// existing read-only string. It's a convenience class used to prevent
+// the creation of std::string() objects un-necessarily.
+//
+// Consider the two following functions:
+//
+// size_t count1(const std::string& str) {
+// size_t count = 0;
+// for (size_t n = 0; n < str.size(); ++n) {
+// if (str[n] == '1') {
+// count++;
+// }
+// }
+// return count;
+// }
+//
+// size_t count2(const StringView& str) {
+// size_t count = 0;
+// for (size_t n = 0; n < str.size(); ++n) {
+// if (str[n] == '2') {
+// count++;
+// }
+// }
+// return count;
+// }
+//
+// Then consider the following calls:
+//
+// size_t n1 = count1("There is 1 one in this string!");
+// size_t n2 = count2("I can count 2 too");
+//
+// In the first case, the compiler will silently create a temporary
+// std::string object, copy the input string into it (allocating memory in
+// the heap), call count1() and destroy the std::string upon its return.
+//
+// In the second case, the compiler will create a temporary StringView,
+// initialize it trivially before calling count2(), this results in
+// much less generated code, as well as better performance.
+//
+// Generally speaking, always use a reference or pointer to StringView
+// instead of a std::string if your function or method doesn't need to modify
+// its input.
+//
+class StringView {
+public:
+ constexpr StringView() : mString(""), mSize(0U) {}
+
+ constexpr StringView(const StringView& other) :
+ mString(other.data()), mSize(other.size()) {}
+
+ // IMPORTANT: all StringView constructors are intentionally not explict
+ // it is needed to allow seamless creation of StringView from all types
+ // of strings around - as it's intended to be a generic string wrapper
+
+ // A constexpr constructor from a constant buffer, initializing |mSize|
+ // as well. This allows one to declare a static const StringView instance
+ // and initialize it at compile time, with no runtime overhead:
+ //
+ // static constexpr StringView message = "blah";
+ //
+ template <size_t size>
+ constexpr StringView(const char (&buf)[size]) :
+ mString(buf), mSize(size - 1) {}
+
+ // Ctor for non-const arrays, AKA buffers. These usually contain some
+ // string formatted at runtime, so call strlen() instead of using the
+ // buffer size.
+ template <size_t size>
+ constexpr StringView(char (&buf)[size]) :
+ mString(buf), mSize(strlen(buf)) {}
+
+ // Constructor from a const char pointer. It has to be templated to make
+ // sure the array-based one is chosen for an array - otherwise non-templated
+ // overload always wins
+ // Note: the parameter type is a const reference to a const pointer. This
+ // is to make this overload a poorer choice for the case of an array. For
+ // the 'const char[]' argument both 'reference to an array' and 'pointer'
+ // overloads are tied, so compiler can't choose without help
+ // Note2: for all constructors and set() calls, |end| must be
+ // dereferencable. It is notrequired to be '\0', but there has to be some
+ // data there. One may not construct a StringView passing past-the-end
+ // iterator as |end|! StringView will try to dereference it.
+ template <class Char, class = enable_if<std::is_same<Char, char>>>
+ constexpr StringView(const Char* const & string) :
+ mString(string ? string : ""), mSize(string ? strlen(string) : 0) {}
+
+ StringView(const std::string& str) :
+ mString(str.c_str()), mSize(str.size()) {}
+
+ constexpr StringView(const char* str, size_t len)
+ : mString(str ? str : ""), mSize(len) {}
+
+ constexpr StringView(const char* begin, const char* end)
+ : mString(begin ? begin : ""), mSize(begin ? end - begin : 0) {}
+
+ constexpr StringView(std::nullptr_t) :
+ mString(""), mSize(0) {}
+
+ std::string str() const { return std::string(mString, mString + mSize); }
+ constexpr const char* data() const { return mString; }
+ constexpr size_t size() const { return mSize; }
+
+ typedef const char* iterator;
+ typedef const char* const_iterator;
+
+ constexpr const_iterator begin() const { return mString; }
+ constexpr const_iterator end() const { return mString + mSize; }
+
+ constexpr bool empty() const { return !size(); }
+ constexpr bool isNullTerminated() const { return *end() == '\0'; }
+
+ void clear() {
+ mSize = 0;
+ mString = "";
+ }
+
+ constexpr char operator[](size_t index) const {
+ return mString[index];
+ }
+
+ void set(const char* data, size_t len) {
+ mString = data ? data : "";
+ mSize = len;
+ }
+
+ void set(const char* str) {
+ mString = str ? str : "";
+ mSize = ::strlen(mString);
+ }
+
+ void set(const StringView& other) {
+ mString = other.mString;
+ mSize = other.mSize;
+ }
+
+ // Compare with another StringView.
+ int compare(const StringView& other) const;
+
+ StringView& operator=(const StringView& other) {
+ set(other);
+ return *this;
+ }
+
+ // find() first occurrence of |other| with an initial offset.
+ // Returns absolute offset (does not include |off|).
+ size_t find(StringView other, size_t off = 0) {
+ // Trivial case
+ if (!other.mSize) return 0;
+
+ size_t safeOff = std::min(off, mSize);
+
+ const char* searchStart = mString + safeOff;
+ const char* searchEnd = searchStart + mSize - safeOff;
+
+ const char* res =
+ std::search(searchStart, searchEnd,
+ other.mString, other.mString + other.mSize);
+ if (res == searchEnd) return std::string::npos;
+ return (size_t)((uintptr_t)res - (uintptr_t)mString);
+ }
+
+ // getSubstr(); returns this string starting at the first place |other|
+ // occurs, otherwise a blank string.
+ StringView getSubstr(StringView other, size_t off = 0) {
+ size_t loc = find(other, off);
+ if (loc == std::string::npos) return StringView("");
+ return { mString + loc, end() };
+ }
+
+ // Returns substring starting at |begin| and running for |len|,
+ // or the rest of the string if |len| is std::string::npos.
+ StringView substr(size_t begin, size_t len = std::string::npos) {
+ if (len == std::string::npos) {
+ len = mSize - begin;
+ }
+ size_t safeOff = std::min(begin, mSize);
+ size_t safeLen = std::min(len, mSize - safeOff);
+ return { mString + safeOff, safeLen };
+ }
+
+ // Returns substring starting at |begin| ending at |end|,
+ // or the rest of the string if |end is std::string::npos.
+ StringView substrAbs(size_t begin, size_t end = std::string::npos) {
+ if (end == std::string::npos) {
+ end = begin + mSize;
+ }
+ return substr(begin, end - begin);
+ }
+
+ // Convert to std::string when needed.
+ operator std::string() const { return std::string(mString, mSize); }
+
+private:
+ const char* mString;
+ size_t mSize;
+};
+
+// Comparison operators. Defined as functions to allow automatic type
+// conversions with C strings and std::string objects.
+
+bool operator==(const StringView& x, const StringView& y);
+
+inline bool operator!=(const StringView& x, const StringView& y) {
+ return !(x == y);
+}
+
+inline bool operator<(const StringView& x, const StringView& y) {
+ return x.compare(y) < 0;
+}
+
+inline bool operator>=(const StringView& x, const StringView& y) {
+ return !(x < y);
+}
+
+inline bool operator >(const StringView& x, const StringView& y) {
+ return x.compare(y) > 0;
+}
+
+inline bool operator<=(const StringView& x, const StringView& y) {
+ return !(x > y);
+}
+
+// Helper to get a null-terminated const char* from a string view.
+// Only allocates if the StringView is not null terminated.
+//
+// Usage:
+//
+// StringView myString = ...;
+// printf("Contents: %s\n", c_str(myString));
+//
+// c_str(...) constructs a temporary object that may allocate memory if the
+// StringView is not null termianted. The lifetime of the temporary object will
+// be until the next sequence point (typically the next semicolon). If the
+// value needs to exist for longer than that, cache the instance.
+//
+// StringView myString = ...;
+// auto myNullTerminatedString = c_str(myString);
+// functionAcceptingConstCharPointer(myNullTerminatedString);
+//
+class CStrWrapper {
+public:
+ CStrWrapper(StringView stringView) : mStringView(stringView) {}
+
+ // Returns a null-terminated char*, potentially creating a copy to add a
+ // null terminator.
+ const char* get() {
+ if (mStringView.isNullTerminated()) {
+ return mStringView.data();
+ } else {
+ // Create the std::string copy on-demand.
+ if (!mStringCopy) {
+ mStringCopy.emplace(mStringView.str());
+ }
+
+ return mStringCopy->c_str();
+ }
+ }
+
+ // Enable casting to const char*
+ operator const char*() { return get(); }
+
+private:
+ const StringView mStringView;
+ Optional<std::string> mStringCopy;
+};
+
+inline CStrWrapper c_str(StringView stringView) {
+ return CStrWrapper(stringView);
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/TypeTraits.h b/android-emu/android/base/TypeTraits.h
new file mode 100644
index 0000000..9ab0060
--- /dev/null
+++ b/android-emu/android/base/TypeTraits.h
@@ -0,0 +1,173 @@
+// Copyright 2015 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 <iterator>
+#include <type_traits>
+
+namespace android {
+namespace base {
+
+namespace details {
+
+// a simple helper class for SFINAE below.
+template <class X = void>
+struct dummy {
+ using type = X;
+};
+
+} // namespaces details
+
+// add some convenience shortcuts for an overly complex std::enable_if syntax
+
+// Use 'enable_if<Predicate,Type>' instead of
+// 'typename std::enable_if<Predicate::value,Type>::type'
+template <class Predicate, class Type = void*>
+using enable_if = typename std::enable_if<Predicate::value, Type>::type;
+
+// Use 'enable_if_c<BooleanFlag,Type>' instead of
+// 'typename std::enable_if<BooleanFlag,Type>::type'
+template <bool predicate, class Type = void*>
+using enable_if_c = typename std::enable_if<predicate, Type>::type;
+
+// Use 'enable_if_convertible<From,To,Type>' instead of
+// 'typename std::enable_if<std::is_convertible<From,To>::value, Type>::type'
+template <class From, class To, class Type = void*>
+using enable_if_convertible = enable_if<std::is_convertible<From, To>>;
+
+// -----------------------------------------------------------------------------
+// A predicate for checking if some object is callable with a specific
+// signature. Examples:
+//
+// is_callable_as<int, void()>::value == false.
+// is_callable_as<strcmp, void()>::value == false.
+// is_callable_as<strcmp, int(const char*, const char*)>::value == true
+//
+template <class F, class Signature, class X = void>
+struct is_callable_as : std::false_type {};
+
+// This specialization is SFINAE-d out if template arguments can't be combined
+// into a call expression F(), or if the result of that call is not |R|
+template <class F, class R, class... Args>
+struct is_callable_as<
+ F,
+ R(Args...),
+ typename std::enable_if<
+ std::is_same<typename details::dummy<decltype(std::declval<F>()(
+ std::declval<Args>()...))>::type,
+ R>::value>::type> : std::true_type {};
+
+//
+// A similar predicate to only check arguments of the function call and ignore
+// the specified return type
+//
+// is_callable_as<strcmp, int(const char*, const char*)>::value == true
+// is_callable_as<strcmp, void(const char*, const char*)>::value == false
+// is_callable_with_args<strcmp, void(const char*, const char*)>::value == true
+//
+template <class F, class Signature, class X = void>
+struct is_callable_with_args : std::false_type {};
+
+template <class F, class R, class... Args>
+struct is_callable_with_args<
+ F,
+ R(Args...),
+ typename std::enable_if<
+ !std::is_same<typename details::dummy<decltype(std::declval<F>()(
+ std::declval<Args>()...))>::type,
+ F>::value>::type> : std::true_type {};
+
+// -----------------------------------------------------------------------------
+// Check if a type |T| is any instantiation of a template |U|. Examples:
+//
+// is_template_instantiation_of<int, std::vector>::value == false
+// is_template_instantiation_of<
+// std::list<std::vector<int>>, std::vector>::value == false
+// is_template_instantiation_of<std::vector<int>, std::vector>::value == true
+// is_template_instantiation_of<
+// std::vector<std::vector<int>>, std::vector>::value == true
+//
+template <class T, template <class...> class U>
+struct is_template_instantiation_of : std::false_type {};
+
+template <template <class...> class U, class... Args>
+struct is_template_instantiation_of<U<Args...>, U> : std::true_type {};
+// -----------------------------------------------------------------------------
+
+//
+// is_range<T> - check if type |T| is a range-like type.
+//
+// It makes sure that expressions std::begin(t) and std::end(t) are well-formed
+// and those return the same type.
+//
+// Note: with expression SFINAE from C++14 is_range_helper<> could be renamed to
+// is_range<> with no extra code. C++11 needs an extra level of enable_if<>
+// to make it work when the type isn't a range.
+//
+
+namespace details {
+
+template <class T>
+using is_range_helper = std::is_same<
+ decltype(std::begin(
+ std::declval<typename std::add_lvalue_reference<T>::type>())),
+ decltype(std::end(
+ std::declval<typename std::add_lvalue_reference<T>::type>()))>;
+
+} // namespace details
+
+template <class T, class = void>
+struct is_range : std::false_type {};
+
+template <class T>
+struct is_range<
+ T,
+ typename std::enable_if<details::is_range_helper<T>::value>::type>
+ : std::true_type {};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A class to incapsulate integer sequence 0, 1, ..., <num_args>
+// Seq<int...>
+// Useful to pass function parameters in an array/tuple to call it later.
+//
+
+template <int...>
+struct Seq {};
+
+// A 'maker' class to construct Seq<int...> given only <num_args>
+// value.
+// MakeSeq<N, S...> works this way, e.g.
+//
+// MakeSeq<2> inherits MakeSeq<2 - 1, 2 - 1> == MakeSeq<1, 1>
+// MakeSeq<1, 1> : MakeSeq<1 - 1, 1 - 1, 1> == MakeSeq<0, 0, 1>
+// MakeSeq<0, 0, 1> == MakeSeq<0, S...> and defines |type| = Seq<0, 1>
+
+template <int N, int... S>
+struct MakeSeq : MakeSeq<N - 1, N - 1, S...> {};
+
+template <int... S>
+struct MakeSeq<0, S...> {
+ using type = Seq<S...>;
+};
+
+//
+// MakeSeqT alias to quickly create Seq<...>:
+// MakeSeqT<3> == Seq<0, 1, 2>
+template <int... S>
+using MakeSeqT = typename MakeSeq<S...>::type;
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/containers/SmallVector.h b/android-emu/android/base/containers/SmallVector.h
new file mode 100644
index 0000000..dc49a70
--- /dev/null
+++ b/android-emu/android/base/containers/SmallVector.h
@@ -0,0 +1,403 @@
+// Copyright 2016 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/TypeTraits.h"
+
+#include <algorithm>
+#include <initializer_list>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include <stddef.h>
+#include <stdlib.h>
+
+//
+// SmallVector<T>, SmallFixedVector<T, SmallSize>
+//
+// This header defines a replacement for a std::vector<> that uses small buffer
+// optimization technique - for some preset number of elements |SmallSize| it
+// stores them inside of the object, and falls back to the dynamically allocated
+// array only if one needs to add more elements.
+// This is useful for the performance-critical places where common number of
+// processed items is small, but it may still be quite large for a stack array.
+//
+// SmallFixedVector<> is the class you use to store elements, while
+// SmallVector<> is its base class that erases the small size from the type.
+//
+// NOTE: SmallVector<> cannot guarantee std::vector<>'s iterator invalidation
+// rules for move() and swap() operations - std::vector<>s just exchange
+// their iterators on swap() and pass the moved ones over, while SmallVector<>
+// may leave the iterators pointing to nowhere if they were for the in-place
+// array storage.
+//
+// Currenly only a limited subset of std::vector<>'s operations is implemented,
+// but fill free to add the ones you need.
+//
+
+namespace android {
+namespace base {
+
+//
+// Forward-declare the 'real' small vector class.
+template <class T, size_t S>
+class SmallFixedVector;
+
+//
+// SmallVector<T> - an interface for a small-buffer-optimized vector.
+// It hides the fixed size from its type, so one can use it to pass small
+// vectors around and not leak the buffer size to all callers:
+//
+// void process(SmallVector<Foo>& data);
+// ...
+// ...
+// SmallFixedVector<Foo, 100> aLittleBitOfFoos = ...;
+// process(aLittleBitOfFoos);
+// ...
+// SmallFixedVector<Foo, 1000> moreFoos = ...;
+// process(moreFoos);
+//
+template <class T>
+class SmallVector {
+ // Make them friends so SmallFixedVector is able to refer to SmallVector's
+ // protected members in static_assert()s.
+ template <class U, size_t S>
+ friend class SmallFixedVector;
+
+public:
+ // Common set of type aliases.
+ using value_type = T;
+ using iterator = T*;
+ using const_iterator = const T*;
+ using pointer = T*;
+ using const_pointer = const T*;
+ using reference = T&;
+ using const_reference = const T&;
+ using size_type = size_t;
+
+ // It's ok to delete SmallVector<> through the base class - dtor() actually
+ // takes care of all living elements and the allocated memory.
+ ~SmallVector() { dtor(); }
+
+ // std::vector<> interface operations.
+ iterator begin() { return mBegin; }
+ const_iterator begin() const { return mBegin; }
+ const_iterator cbegin() const { return mBegin; }
+
+ iterator end() { return mEnd; }
+ const_iterator end() const { return mEnd; }
+ const_iterator cend() const { return mEnd; }
+
+ size_type size() const { return end() - begin(); }
+ size_type capacity() const { return mCapacity; }
+ bool empty() const { return begin() == end(); }
+
+ reference front() { return *begin(); }
+ const_reference front() const { return *cbegin(); }
+ reference back() { return *(end() - 1); }
+ const_reference back() const { return *(cend() - 1); }
+
+ reference operator[](size_t i) { return *(begin() + i); }
+ const_reference operator[](size_t i) const { return *(cbegin() + i); }
+
+ pointer data() { return mBegin; }
+ const_pointer data() const { return mBegin; }
+ const_pointer cdata() const { return mBegin; }
+
+ template <class... Args>
+ void emplace_back(Args&&... args) {
+ grow_for_size(size() + 1);
+ new (mEnd) T(std::forward<Args>(args)...);
+ ++mEnd;
+ }
+
+ void push_back(const T& t) { emplace_back(t); }
+ void push_back(T&& t) { emplace_back(std::move(t)); }
+
+ void pop_back() {
+ destruct(mEnd - 1, mEnd);
+ --mEnd;
+ }
+
+ void clear() {
+ destruct(begin(), end());
+ mEnd = mBegin;
+ }
+
+ void reserve(size_type newCap) {
+ if (newCap <= this->capacity()) {
+ return;
+ }
+ set_capacity(newCap);
+ }
+
+ void resize(size_type newSize) { resize_impl<true>(newSize); }
+
+ // This version of resizing doesn't initialize the newly allocated elements
+ // Useful for the cases when value-initialization is noticeably slow and
+ // one wants to directly construct or memcpy the elements into the resized
+ // place.
+ void resize_noinit(size_type newSize) { resize_impl<false>(newSize); }
+
+ // Returns if the current vector's buffer is dynamically allocated.
+ bool isAllocated() const { return this->cbegin() != smallBufferStart(); }
+
+protected:
+ // Hide the default constructor so only SmallFixedVector can be
+ // instantiated.
+ SmallVector() = default;
+
+ // Destroy all elements in the vector and free the array if it was allocated
+ // dynamically.
+ void dtor() {
+ this->destruct(this->begin(), this->end());
+ if (isAllocated()) {
+ free(this->mBegin);
+ }
+ }
+
+ // Just a convenience setter function to init all members at once.
+ void init(iterator begin, iterator end, size_type capacity) {
+ this->mBegin = begin;
+ this->mEnd = end;
+ this->mCapacity = capacity;
+ }
+
+ // An implementation of different resizing versions.
+ template <bool init>
+ void resize_impl(size_type newSize) {
+ if (newSize < this->size()) {
+ const auto newEnd = this->begin() + newSize;
+ this->destruct(newEnd, this->end());
+ this->mEnd = newEnd;
+ } else if (newSize > this->size()) {
+ grow_for_size(newSize);
+ const auto newEnd = this->begin() + newSize;
+ if (init) {
+ std::uninitialized_fill(this->end(), newEnd, T());
+ }
+ this->mEnd = newEnd;
+ }
+ }
+
+ // Templated append operation for a range of elements.
+ template <class Iter>
+ void insert_back(Iter b, Iter e) {
+ if (b == e) {
+ return;
+ }
+ const auto newSize = this->size() + (e - b);
+ grow_for_size(newSize);
+ this->mEnd = std::uninitialized_copy(b, e, this->mEnd);
+ }
+
+ // Multiplicative grow for the internal array so it can hold |newSize|
+ // elements.
+ // Doesn't change size(), only capacity().
+ void grow_for_size(size_type newSize) {
+ // Grow by 1.5x by default.
+ if (newSize > capacity()) {
+ set_capacity(std::max(newSize, capacity() + capacity() / 2));
+ }
+ }
+
+ // Sets the capacity() to be exacly |newCap|. Allocates the array
+ // dynamically, moves all elements over and (potentially) deallocates the
+ // old array.
+ // Doesn't change size(), only capacity().
+ void set_capacity(size_type newCap) {
+ // Here we can only be switching to the dynamic vector, as static one
+ // always has its capacity on the maximum.
+ const auto newBegin = (T*)malloc(sizeof(T) * newCap);
+ if (!newBegin) {
+ abort(); // what else can we do here?
+ }
+ const auto newEnd = std::uninitialized_copy(
+ std::make_move_iterator(this->begin()),
+ std::make_move_iterator(this->end()), newBegin);
+ dtor();
+ this->mBegin = newBegin;
+ this->mEnd = newEnd;
+ this->mCapacity = newCap;
+ }
+
+ // A convenience function to call destructor for a range of elements.
+ static void destruct(T* b, T* e) {
+ if (!std::is_trivially_destructible<T>::value) {
+ for (; b != e; ++b) {
+ b->~T();
+ }
+ }
+ }
+
+ // By design of the class, SmallFixedVector<> will be inheriting from
+ // SmallVector<>, so its in-place storage array is going to be the very next
+ // member after the last one here.
+ // This function returns that address, and SmallFixedVector<> has a static
+ // assert to make sure it remains correct.
+ constexpr const void* smallBufferStart() const {
+ return (const void*)(&mCapacity + 1);
+ }
+
+ // Standard set of members for a vector - begin, end and capacity.
+ // These point to the currently used chunk of memory, no matter if it's a
+ // heap-allocated one or an in-place array.
+ iterator mBegin;
+ iterator mEnd;
+ size_type mCapacity;
+};
+
+// The implementation of a SmallVector with a fixed in-place size, |SmallSize|.
+template <class T, size_t SmallSize>
+class SmallFixedVector : public SmallVector<T> {
+ using base = SmallVector<T>;
+
+public:
+ // Grab these from the base class.
+ using value_type = typename base::value_type;
+ using iterator = typename base::iterator;
+ using const_iterator = typename base::const_iterator;
+ using pointer = typename base::pointer;
+ using const_pointer = typename base::const_pointer;
+ using reference = typename base::reference;
+ using const_reference = typename base::const_reference;
+ using size_type = typename base::size_type;
+
+ static constexpr size_type kSmallSize = SmallSize;
+
+ // Default constructor - set up an empty vector with capacity at full
+ // internal array size.
+ SmallFixedVector() {
+ // Make sure that the small array starts exactly where base class
+ // expects it: right after the |mCapacity|.
+
+ // We can't use a static_assert with offsetof() because in msvc, it uses
+ // reinterpret_cast.
+ // TODO: Add runtime assertion instead?
+ // https://developercommunity.visualstudio.com/content/problem/22196/static-assert-cannot-compile-constexprs-method-tha.html
+#ifndef _MSC_VER
+ static_assert(offsetof(base, mCapacity) + sizeof(base::mCapacity) ==
+ offsetof(SmallFixedVector, mData) &&
+ offsetof(Data, array) == 0,
+ "SmallFixedVector<> class layout is wrong, "
+ "|mData| needs to follow |mCapacity|");
+#endif
+
+ init_inplace();
+ }
+
+ // Ctor from a range of iterators
+ template <class Iter>
+ SmallFixedVector(Iter b, Iter e) : SmallFixedVector() {
+ this->insert_back(b, e);
+ }
+
+ // Ctor from a range - anything that has begin and end.
+ // Note: template constructor is never a copy/move-ctor.
+ template <class Range,
+ class = enable_if_c<!std::is_same<Range, T>::value &&
+ is_range<Range>::value>>
+ explicit SmallFixedVector(const Range& r)
+ : SmallFixedVector(std::begin(r), std::end(r)) {}
+ template <class Range,
+ class = enable_if_c<!std::is_same<Range, T>::value &&
+ is_range<Range>::value>>
+ explicit SmallFixedVector(Range&& r)
+ : SmallFixedVector(std::make_move_iterator(std::begin(r)),
+ std::make_move_iterator(std::end(r))) {}
+ template <class U, class = enable_if_convertible<U, T>>
+ SmallFixedVector(std::initializer_list<U> list)
+ : SmallFixedVector(std::begin(list), std::end(list)) {}
+
+ SmallFixedVector(const SmallFixedVector& other)
+ : SmallFixedVector(other.begin(), other.end()) {}
+
+ SmallFixedVector(SmallFixedVector&& other) {
+ if (other.isAllocated()) {
+ // Just steal the allocated memory from the |other|.
+ this->mBegin = other.mBegin;
+ this->mEnd = other.mEnd;
+ this->mCapacity = other.mCapacity;
+ other.init_inplace();
+ } else {
+ // Have to move individual elements.
+ this->mBegin = mData.array;
+ this->mEnd = std::uninitialized_copy(
+ std::make_move_iterator(other.begin()),
+ std::make_move_iterator(other.end()), this->begin());
+ this->mCapacity = kSmallSize;
+ }
+ }
+
+ SmallFixedVector& operator=(const SmallFixedVector& other) {
+ if (&other != this) {
+ this->clear();
+ this->insert_back(other.begin(), other.end());
+ }
+ return *this;
+ }
+
+ SmallFixedVector& operator=(SmallFixedVector&& other) {
+ if (other.isAllocated()) {
+ // Steal it and we're done.
+ this->dtor();
+ this->mBegin = other.mBegin;
+ this->mEnd = other.mEnd;
+ this->mCapacity = other.mCapacity;
+ other.init_inplace();
+ return *this;
+ }
+
+ if (this->isAllocated() && this->mCapacity < other.size()) {
+ // Not enough dynamic memory, switch to in-place.
+ this->dtor();
+ init_inplace();
+ } else {
+ // This could potentially be improved by move-assigning
+ // only needed items and destroying the rest, but
+ // destroy-all+construct-all is just simpler. For PODs it actually
+ // is even faster as it's always a single memcpy().
+ this->destruct(this->begin(), this->end());
+ }
+
+ // Move the whole |other| into the pre-cleaned memory
+ const auto newEnd = std::uninitialized_copy(
+ std::make_move_iterator(other.begin()),
+ std::make_move_iterator(other.end()), this->mBegin);
+ this->mEnd = newEnd;
+ // |other| is valid as-is.
+ return *this;
+ }
+
+ // Make sure we don't end up trying to move from an interface - it's just
+ // inefficient with the current code.
+ SmallFixedVector(base&& other) = delete;
+ SmallFixedVector& operator=(base&& other) = delete;
+
+private:
+ // A shortcut for initialization for in-place storage.
+ void init_inplace() { this->init(mData.array, mData.array, kSmallSize); }
+
+ // A union with empty constructor and destructor makes sure that the array
+ // elements are not default-constructed in ctor and not destructed in dtor:
+ // the class needs to be able manage their lifetime more precisely.
+ union Data {
+ alignas(size_type) T array[kSmallSize];
+
+ Data() {}
+ ~Data() {}
+ } mData;
+};
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/files/MemStream.cpp b/android-emu/android/base/files/MemStream.cpp
new file mode 100644
index 0000000..4f8291f
--- /dev/null
+++ b/android-emu/android/base/files/MemStream.cpp
@@ -0,0 +1,62 @@
+// Copyright 2015 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#include "android/base/files/MemStream.h"
+
+#include "android/base/files/StreamSerializing.h"
+
+#include <algorithm>
+#include <utility>
+
+namespace android {
+namespace base {
+
+MemStream::MemStream(int reserveSize) {
+ mData.reserve(reserveSize);
+}
+
+MemStream::MemStream(Buffer&& data) : mData(std::move(data)) {}
+
+ssize_t MemStream::read(void* buffer, size_t size) {
+ const auto sizeToRead = std::min<int>(size, readSize());
+ memcpy(buffer, mData.data() + mReadPos, sizeToRead);
+ mReadPos += sizeToRead;
+ return sizeToRead;
+}
+
+ssize_t MemStream::write(const void* buffer, size_t size) {
+ mData.insert(mData.end(), (const char*)buffer, (const char*)buffer + size);
+ return size;
+}
+
+int MemStream::writtenSize() const {
+ return (int)mData.size();
+}
+
+int MemStream::readPos() const {
+ return mReadPos;
+}
+
+int MemStream::readSize() const {
+ return mData.size() - mReadPos;
+}
+
+void MemStream::save(Stream* stream) const {
+ saveBuffer(stream, mData);
+}
+
+void MemStream::load(Stream* stream) {
+ loadBuffer(stream, &mData);
+ mReadPos = 0;
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/files/MemStream.h b/android-emu/android/base/files/MemStream.h
new file mode 100644
index 0000000..e256a68
--- /dev/null
+++ b/android-emu/android/base/files/MemStream.h
@@ -0,0 +1,55 @@
+// Copyright 2015 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/Compiler.h"
+#include "android/base/files/Stream.h"
+
+#include <vector>
+
+namespace android {
+namespace base {
+
+// An implementation of the Stream interface on top of a vector.
+class MemStream : public Stream {
+public:
+ using Buffer = std::vector<char>;
+
+ MemStream(int reserveSize = 512);
+ MemStream(Buffer&& data);
+
+ MemStream(MemStream&& other) = default;
+ MemStream& operator=(MemStream&& other) = default;
+
+ int writtenSize() const;
+ int readPos() const;
+ int readSize() const;
+
+ // Stream interface implementation.
+ ssize_t read(void* buffer, size_t size) override;
+ ssize_t write(const void* buffer, size_t size) override;
+
+ // Snapshot support.
+ void save(Stream* stream) const;
+ void load(Stream* stream);
+
+ const Buffer& buffer() const { return mData; }
+
+private:
+ DISALLOW_COPY_AND_ASSIGN(MemStream);
+
+ Buffer mData;
+ int mReadPos = 0;
+};
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/files/Stream.cpp b/android-emu/android/base/files/Stream.cpp
new file mode 100644
index 0000000..dd4c9ef
--- /dev/null
+++ b/android-emu/android/base/files/Stream.cpp
@@ -0,0 +1,184 @@
+// Copyright 2015 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#include "android/base/files/Stream.h"
+
+#include <assert.h>
+#include <string.h>
+
+namespace android {
+namespace base {
+
+void Stream::putByte(uint8_t value) {
+ write(&value, 1U);
+}
+
+uint8_t Stream::getByte() {
+ uint8_t value[1] = { 0 };
+ read(value, 1U);
+ return value[0];
+}
+
+void Stream::putBe16(uint16_t value) {
+ uint8_t b[2] = { (uint8_t)(value >> 8), (uint8_t)value };
+ write(b, 2U);
+}
+
+uint16_t Stream::getBe16() {
+ uint8_t b[2] = { 0, 0 };
+ read(b, 2U);
+ return ((uint16_t)b[0] << 8) | (uint16_t)b[1];
+}
+
+void Stream::putBe32(uint32_t value) {
+ uint8_t b[4] = {
+ (uint8_t)(value >> 24),
+ (uint8_t)(value >> 16),
+ (uint8_t)(value >> 8),
+ (uint8_t)value };
+ write(b, 4U);
+}
+
+uint32_t Stream::getBe32() {
+ uint8_t b[4] = { 0, 0, 0, 0 };
+ read(b, 4U);
+ return ((uint32_t)b[0] << 24) |
+ ((uint32_t)b[1] << 16) |
+ ((uint32_t)b[2] << 8) |
+ (uint32_t)b[3];
+}
+
+void Stream::putBe64(uint64_t value) {
+ uint8_t b[8] = {
+ (uint8_t)(value >> 56),
+ (uint8_t)(value >> 48),
+ (uint8_t)(value >> 40),
+ (uint8_t)(value >> 32),
+ (uint8_t)(value >> 24),
+ (uint8_t)(value >> 16),
+ (uint8_t)(value >> 8),
+ (uint8_t)value };
+ write(b, 8U);
+}
+
+uint64_t Stream::getBe64() {
+ uint8_t b[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+ read(b, 8U);
+ return ((uint64_t)b[0] << 56) |
+ ((uint64_t)b[1] << 48) |
+ ((uint64_t)b[2] << 40) |
+ ((uint64_t)b[3] << 32) |
+ ((uint64_t)b[4] << 24) |
+ ((uint64_t)b[5] << 16) |
+ ((uint64_t)b[6] << 8) |
+ (uint64_t)b[7];
+}
+
+void Stream::putFloat(float v) {
+ union {
+ float f;
+ uint8_t bytes[sizeof(float)];
+ } u;
+ u.f = v;
+ this->write(u.bytes, sizeof(u.bytes));
+}
+
+float Stream::getFloat() {
+ union {
+ float f;
+ uint8_t bytes[sizeof(float)];
+ } u;
+ this->read(u.bytes, sizeof(u.bytes));
+ return u.f;
+}
+
+void Stream::putString(StringView str) {
+ this->putBe32(str.size());
+ this->write(str.data(), str.size());
+}
+
+void Stream::putString(const char* str) {
+ putString(StringView(str));
+}
+
+void Stream::putString(const char* str, size_t len) {
+ putString(StringView(str, len));
+}
+
+std::string Stream::getString() {
+ std::string result;
+ size_t len = this->getBe32();
+ if (len > 0) {
+ result.resize(len);
+ if (this->read(&result[0], len) != static_cast<ssize_t>(len)) {
+ result.clear();
+ }
+ }
+#ifdef _WIN32
+ else {
+ // std::string in GCC's STL still uses copy on write implementation
+ // with a single shared buffer for an empty string. Its dtor has
+ // a check for that shared buffer, and it deallocates memory only if
+ // the current string's instance address != shared empty string address
+ // Unfortunately, in Windows DLLs each DLL has its own copy of this
+ // empty string (that's just the way Windows DLLs work), so if this
+ // code creates an empty string and passes it over into another module,
+ // that module's std::string::~string() will compare address with its
+ // empty string object, find that they are different and will try to
+ // free() a static object.
+ // To mitigate it we make sure the string allocates something, so it
+ // isn't empty internally and dtor is OK to delete the storage.
+ result.reserve(1);
+ }
+#endif
+ return result;
+}
+
+void Stream::putPackedNum(uint64_t num) {
+ do {
+ auto byte = uint8_t(num & 0x7f);
+ num >>= 7;
+ if (num) {
+ byte |= 0x80;
+ }
+ putByte(byte);
+ } while (num != 0);
+}
+
+uint64_t Stream::getPackedNum() {
+ uint64_t res = 0;
+ uint8_t byte;
+ int i = 0;
+ do {
+ byte = getByte();
+ res |= uint64_t(byte & 0x7f) << (i++ * 7);
+ } while (byte & 0x80 && i < 10);
+ return res;
+}
+
+void Stream::putPackedSignedNum(int64_t num) {
+ if (num >= 0) {
+ assert((uint64_t(num) & (1ULL << 63)) == 0);
+ putPackedNum(uint64_t(num) << 1);
+ } else {
+ assert((uint64_t(-num) & (1ULL << 63)) == 0);
+ putPackedNum((uint64_t(-num) << 1) | 1);
+ }
+}
+
+int64_t Stream::getPackedSignedNum() {
+ auto num = getPackedNum();
+ auto sign = num & 1;
+ return sign ? -int64_t(num >> 1) : (num >> 1);
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/files/Stream.h b/android-emu/android/base/files/Stream.h
new file mode 100644
index 0000000..8e2b0a0
--- /dev/null
+++ b/android-emu/android/base/files/Stream.h
@@ -0,0 +1,109 @@
+// Copyright 2015 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/StringView.h"
+
+#include <string>
+
+#include <inttypes.h>
+#include <sys/types.h>
+
+namespace android {
+namespace base {
+
+// Abstract interface to byte streams of all kind.
+// This is mainly used to implement disk serialization.
+class Stream {
+public:
+ // Default constructor.
+ Stream() = default;
+
+ // Destructor.
+ virtual ~Stream() = default;
+
+ // Read up to |size| bytes and copy them to |buffer|. Return the number
+ // of bytes that were actually transferred, or -errno value on error.
+ virtual ssize_t read(void* buffer, size_t size) = 0;
+
+ // Write up to |size| bytes from |buffer| into the stream. Return the
+ // number of bytes that were actually transferred, or -errno value on
+ // error.
+ virtual ssize_t write(const void* buffer, size_t size) = 0;
+
+ // Write a single byte |value| into the stream. Ignore errors.
+ void putByte(uint8_t value);
+
+ // Write a 16-bit |value| as big-endian into the stream. Ignore errors.
+ void putBe16(uint16_t value);
+
+ // Write a 32-bit |value| as big-endian into the stream. Ignore errors.
+ void putBe32(uint32_t value);
+
+ // Write a 64-bit |value| as big-endian into the stream. Ignore errors.
+ void putBe64(uint64_t value);
+
+ // Read a single byte from the stream. Return 0 on error.
+ uint8_t getByte();
+
+ // Read a single big-endian 16-bit value from the stream.
+ // Return 0 on error.
+ uint16_t getBe16();
+
+ // Read a single big-endian 32-bit value from the stream.
+ // Return 0 on error.
+ uint32_t getBe32();
+
+ // Read a single big-endian 64-bit value from the stream.
+ // Return 0 on error.
+ uint64_t getBe64();
+
+ // Write a 32-bit float |value| to the stream.
+ void putFloat(float value);
+
+ // Read a single 32-bit float value from the stream.
+ float getFloat();
+
+ // Write a string |str| into the stream. Ignore errors.
+ void putString(StringView str);
+
+ // Write a 0-terminated C string |str| into the stream. Ignore error.
+ void putString(const char* str);
+
+ // Write a string |str| of |strlen| bytes into the stream.
+ // Ignore errors.
+ void putString(const char* str, size_t strlen);
+
+ // Read a string from the stream. Return a new string instance,
+ // which will be empty on error. Note that this can only be used
+ // to read strings that were written with putString().
+ std::string getString();
+
+ // Put/gen an integer number into the stream, making it use as little space
+ // there as possible.
+ // It uses a simple byte-by-byte encoding scheme, putting 7 bits of the
+ // number with the 8th bit set when there's more data to read, until the
+ // whole number is read.
+ // The compression is efficient if the number range is small, but it starts
+ // wasting space when values approach 14 bits for int16 (16K), 28 bits for
+ // int32 (268M) or 56 bits for int64 (still a lot).
+ void putPackedNum(uint64_t num);
+ uint64_t getPackedNum();
+
+ // Same thing, but encode negative numbers efficiently as well (single sign
+ // bit + packed unsigned representation)
+ void putPackedSignedNum(int64_t num);
+ int64_t getPackedSignedNum();
+};
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/files/StreamSerializing.cpp b/android-emu/android/base/files/StreamSerializing.cpp
new file mode 100644
index 0000000..2a9d77a
--- /dev/null
+++ b/android-emu/android/base/files/StreamSerializing.cpp
@@ -0,0 +1,53 @@
+// Copyright 2017 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#include "android/base/files/StreamSerializing.h"
+
+namespace android {
+namespace base {
+
+void saveStream(Stream* stream, const MemStream& memStream) {
+ memStream.save(stream);
+}
+
+void loadStream(Stream* stream, MemStream* memStream) {
+ memStream->load(stream);
+}
+
+void saveBufferRaw(Stream* stream, char* buffer, uint32_t len) {
+ stream->putBe32(len);
+ stream->write(buffer, len);
+}
+
+bool loadBufferRaw(Stream* stream, char* buffer) {
+ auto len = stream->getBe32();
+ int ret = (int)stream->read(buffer, len);
+ return ret == (int)len;
+}
+
+void saveStringArray(Stream* stream, const char* const* strings, uint32_t count) {
+ stream->putBe32(count);
+ for (uint32_t i = 0; i < count; ++i) {
+ stream->putString(strings[i]);
+ }
+}
+
+std::vector<std::string> loadStringArray(Stream* stream) {
+ uint32_t count = stream->getBe32();
+ std::vector<std::string> res;
+ for (uint32_t i = 0; i < count; ++i) {
+ res.push_back(stream->getString());
+ }
+ return res;
+}
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/files/StreamSerializing.h b/android-emu/android/base/files/StreamSerializing.h
new file mode 100644
index 0000000..8e56a6e
--- /dev/null
+++ b/android-emu/android/base/files/StreamSerializing.h
@@ -0,0 +1,114 @@
+// Copyright 2017 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#include "android/base/containers/SmallVector.h"
+#include "android/base/files/MemStream.h"
+#include "android/base/files/Stream.h"
+#include "android/base/TypeTraits.h"
+
+#include <string>
+#include <vector>
+
+namespace android {
+namespace base {
+
+//
+// Save/load operations for different types.
+//
+
+void saveStream(Stream* stream, const MemStream& memStream);
+void loadStream(Stream* stream, MemStream* memStream);
+
+void saveBufferRaw(Stream* stream, char* buffer, uint32_t len);
+bool loadBufferRaw(Stream* stream, char* buffer);
+
+template <class T, class = enable_if<std::is_standard_layout<T>>>
+void saveBuffer(Stream* stream, const std::vector<T>& buffer) {
+ stream->putBe32(buffer.size());
+ stream->write(buffer.data(), sizeof(T) * buffer.size());
+}
+
+template <class T, class = enable_if<std::is_standard_layout<T>>>
+bool loadBuffer(Stream* stream, std::vector<T>* buffer) {
+ auto len = stream->getBe32();
+ buffer->resize(len);
+ int ret = (int)stream->read(buffer->data(), len * sizeof(T));
+ return ret == len * sizeof(T);
+}
+
+template <class T, class = enable_if<std::is_standard_layout<T>>>
+void saveBuffer(Stream* stream, const SmallVector<T>& buffer) {
+ stream->putBe32(buffer.size());
+ stream->write(buffer.data(), sizeof(T) * buffer.size());
+}
+
+template <class T, class = enable_if<std::is_standard_layout<T>>>
+bool loadBuffer(Stream* stream, SmallVector<T>* buffer) {
+ auto len = stream->getBe32();
+ buffer->clear();
+ buffer->resize_noinit(len);
+ int ret = (int)stream->read(buffer->data(), len * sizeof(T));
+ return ret == len * sizeof(T);
+}
+
+template <class T, class SaveFunc>
+void saveBuffer(Stream* stream, const std::vector<T>& buffer, SaveFunc&& saver) {
+ stream->putBe32(buffer.size());
+ for (const auto& val : buffer) {
+ saver(stream, val);
+ }
+}
+
+template <class T>
+void saveBuffer(Stream* stream, const T* buffer, size_t numElts) {
+ stream->putBe32(numElts);
+ stream->write(buffer, sizeof(T) * numElts);
+}
+
+template <class T>
+void loadBufferPtr(Stream* stream, T* out) {
+ auto len = stream->getBe32();
+ stream->read(out, len * sizeof(T));
+}
+
+template <class T, class LoadFunc>
+void loadBuffer(Stream* stream, std::vector<T>* buffer, LoadFunc&& loader) {
+ auto len = stream->getBe32();
+ buffer->clear();
+ buffer->reserve(len);
+ for (uint32_t i = 0; i < len; i++) {
+ buffer->emplace_back(loader(stream));
+ }
+}
+
+template <class Collection, class SaveFunc>
+void saveCollection(Stream* stream, const Collection& c, SaveFunc&& saver) {
+ stream->putBe32(c.size());
+ for (const auto& val : c) {
+ saver(stream, val);
+ }
+}
+
+template <class Collection, class LoadFunc>
+void loadCollection(Stream* stream, Collection* c, LoadFunc&& loader) {
+ const int size = stream->getBe32();
+ for (int i = 0; i < size; ++i) {
+ c->emplace(loader(stream));
+ }
+}
+
+void saveStringArray(Stream* stream, const char* const* strings, uint32_t count);
+std::vector<std::string> loadStringArray(Stream* stream);
+
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/synchronization/AndroidLock.h b/android-emu/android/base/synchronization/AndroidLock.h
new file mode 100644
index 0000000..74877d4
--- /dev/null
+++ b/android-emu/android/base/synchronization/AndroidLock.h
@@ -0,0 +1,247 @@
+// Copyright (C) 2014 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "android/base/Compiler.h"
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif
+
+#include <assert.h>
+
+#define AEMU_DEBUG 0
+
+#if AEMU_DEBUG
+#define AEMU_IF_DEBUG(x) x
+#else
+#define AEMU_IF_DEBUG(x)
+#endif
+
+namespace android {
+namespace base {
+namespace guest {
+
+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 {
+public:
+ using AutoLock = android::base::guest::AutoLock;
+
+ constexpr StaticLock() = default;
+
+ // Acquire the lock.
+ void lock() {
+#ifdef _WIN32
+ ::AcquireSRWLockExclusive(&mLock);
+#else
+ ::pthread_mutex_lock(&mLock);
+#endif
+ AEMU_IF_DEBUG(mIsLocked = true;)
+ }
+
+ bool tryLock() {
+ bool ret = false;
+#ifdef _WIN32
+ ret = ::TryAcquireSRWLockExclusive(&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
+ ::ReleaseSRWLockExclusive(&mLock);
+#else
+ ::pthread_mutex_unlock(&mLock);
+#endif
+ }
+
+protected:
+ friend class ConditionVariable;
+
+#ifdef _WIN32
+ // Benchmarks show that on Windows SRWLOCK performs a little bit better than
+ // CRITICAL_SECTION for uncontended mode and much better in case of
+ // contention.
+ SRWLOCK mLock = SRWLOCK_INIT;
+#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 {
+public:
+ using StaticLock::AutoLock;
+
+ constexpr Lock() = default;
+#ifndef _WIN32
+ // The only difference is that POSIX requires a deallocation function call
+ // for its mutexes.
+ ~Lock() { ::pthread_mutex_destroy(&mLock); }
+#endif
+};
+
+class ReadWriteLock {
+public:
+ using AutoWriteLock = android::base::guest::AutoWriteLock;
+ using AutoReadLock = android::base::guest::AutoReadLock;
+
+#ifdef _WIN32
+ constexpr ReadWriteLock() = default;
+ ~ReadWriteLock() = default;
+ void lockRead() { ::AcquireSRWLockShared(&mLock); }
+ void unlockRead() { ::ReleaseSRWLockShared(&mLock); }
+ void lockWrite() { ::AcquireSRWLockExclusive(&mLock); }
+ void unlockWrite() { ::ReleaseSRWLockExclusive(&mLock); }
+
+private:
+ SRWLOCK mLock = SRWLOCK_INIT;
+#else // !_WIN32
+ ReadWriteLock() { ::pthread_rwlock_init(&mLock, NULL); }
+ ~ReadWriteLock() { ::pthread_rwlock_destroy(&mLock); }
+ void lockRead() { ::pthread_rwlock_rdlock(&mLock); }
+ void unlockRead() { ::pthread_rwlock_unlock(&mLock); }
+ void lockWrite() { ::pthread_rwlock_wrlock(&mLock); }
+ void unlockWrite() { ::pthread_rwlock_unlock(&mLock); }
+
+private:
+ pthread_rwlock_t mLock;
+#endif // !_WIN32
+
+ friend class ConditionVariable;
+ DISALLOW_COPY_ASSIGN_AND_MOVE(ReadWriteLock);
+};
+
+// Helper class to lock / unlock a mutex automatically on scope
+// entry and exit.
+// NB: not thread-safe (as opposed to the Lock class)
+class AutoLock {
+public:
+ AutoLock(StaticLock& lock) : mLock(lock) { mLock.lock(); }
+
+ AutoLock(AutoLock&& other) : mLock(other.mLock), mLocked(other.mLocked) {
+ other.mLocked = false;
+ }
+
+ void lock() {
+ assert(!mLocked);
+ mLock.lock();
+ mLocked = true;
+ }
+
+ void unlock() {
+ assert(mLocked);
+ mLock.unlock();
+ mLocked = false;
+ }
+
+ bool isLocked() const { return mLocked; }
+
+ ~AutoLock() {
+ if (mLocked) {
+ mLock.unlock();
+ }
+ }
+
+private:
+ StaticLock& mLock;
+ bool mLocked = true;
+
+ friend class ConditionVariable;
+ // Don't allow move because this class has a non-movable object.
+ DISALLOW_COPY_AND_ASSIGN(AutoLock);
+};
+
+class AutoWriteLock {
+public:
+ AutoWriteLock(ReadWriteLock& lock) : mLock(lock) { mLock.lockWrite(); }
+
+ void lockWrite() {
+ assert(!mWriteLocked);
+ mLock.lockWrite();
+ mWriteLocked = true;
+ }
+
+ void unlockWrite() {
+ assert(mWriteLocked);
+ mLock.unlockWrite();
+ mWriteLocked = false;
+ }
+
+ ~AutoWriteLock() {
+ if (mWriteLocked) {
+ mLock.unlockWrite();
+ }
+ }
+
+private:
+ ReadWriteLock& mLock;
+ bool mWriteLocked = true;
+ // This class has a non-movable object.
+ DISALLOW_COPY_ASSIGN_AND_MOVE(AutoWriteLock);
+};
+
+class AutoReadLock {
+public:
+ AutoReadLock(ReadWriteLock& lock) : mLock(lock) { mLock.lockRead(); }
+
+ void lockRead() {
+ assert(!mReadLocked);
+ mLock.lockRead();
+ mReadLocked = true;
+ }
+
+ void unlockRead() {
+ assert(mReadLocked);
+ mLock.unlockRead();
+ mReadLocked = false;
+ }
+
+ ~AutoReadLock() {
+ if (mReadLocked) {
+ mLock.unlockRead();
+ }
+ }
+
+private:
+ ReadWriteLock& mLock;
+ bool mReadLocked = true;
+ // This class has a non-movable object.
+ DISALLOW_COPY_ASSIGN_AND_MOVE(AutoReadLock);
+};
+
+} // namespace guest
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/utils/compiler.h b/android-emu/android/utils/compiler.h
new file mode 100644
index 0000000..0d72fee
--- /dev/null
+++ b/android-emu/android/utils/compiler.h
@@ -0,0 +1,29 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#pragma once
+
+#ifdef __cplusplus
+#define ANDROID_BEGIN_HEADER extern "C" {
+#define ANDROID_END_HEADER }
+#else
+#define ANDROID_BEGIN_HEADER /* nothing */
+#define ANDROID_END_HEADER /* nothing */
+#endif
+
+// ANDROID_GCC_PREREQ(<major>,<minor>) will evaluate to true
+// iff the current version of GCC is <major>.<minor> or higher.
+#if defined(__GNUC__) && defined(__GNUC_MINOR__)
+# define ANDROID_GCC_PREREQ(maj, min) \
+ ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
+#else
+# define ANDROID_GCC_PREREQ(maj, min) 0
+#endif
diff --git a/android-emu/android/utils/debug.c b/android-emu/android/utils/debug.c
new file mode 100644
index 0000000..238bd87
--- /dev/null
+++ b/android-emu/android/utils/debug.c
@@ -0,0 +1,171 @@
+/* Copyright (C) 2007-2008 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+*/
+#include "android/utils/debug.h"
+
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+uint64_t android_verbose = 0;
+
+void
+dprint( const char* format, ... )
+{
+ va_list args;
+ va_start( args, format );
+ fprintf( stdout, "emulator: ");
+ vfprintf( stdout, format, args );
+ fprintf( stdout, "\n" );
+ va_end( args );
+}
+
+
+void
+dprintn( const char* format, ... )
+{
+ va_list args;
+ va_start( args, format );
+ vfprintf( stdout, format, args );
+ va_end( args );
+}
+
+void
+dprintnv( const char* format, va_list args )
+{
+ vfprintf( stdout, format, args );
+}
+
+
+void
+dwarning( const char* format, ... )
+{
+ va_list args;
+ va_start( args, format );
+ dprintn( "emulator: WARNING: " );
+ dprintnv( format, args );
+ dprintn( "\n" );
+ va_end( args );
+}
+
+
+void
+derror( const char* format, ... )
+{
+ va_list args;
+ va_start( args, format );
+ dprintn( "emulator: ERROR: " );
+ dprintnv( format, args );
+ dprintn( "\n" );
+ va_end( args );
+}
+
+void
+android_tid_function_print(
+ bool use_emulator_prefix,
+ const char* function,
+ const char* format, ... )
+{
+ int tid = syscall(SYS_gettid);
+ va_list args;
+ va_start(args, format);
+ const char* prefix = use_emulator_prefix ? "emulator: " : "";
+ if (function) {
+ printf("%stid=0x%x: %s: ", prefix, tid,
+ function);
+ } else {
+ printf("%stid=0x%x: ", prefix, tid);
+ }
+
+ vprintf(format, args);
+ printf("\n");
+ va_end(args);
+}
+
+/** STDOUT/STDERR REDIRECTION
+ **
+ ** allows you to shut temporarily shutdown stdout/stderr
+ ** this is useful to get rid of debug messages from ALSA and esd
+ ** on Linux.
+ **/
+static int stdio_disable_count;
+static int stdio_save_out_fd;
+static int stdio_save_err_fd;
+
+#ifdef _WIN32
+extern void
+stdio_disable( void )
+{
+ if (++stdio_disable_count == 1) {
+ int null_fd, out_fd, err_fd;
+ fflush(stdout);
+ out_fd = _fileno(stdout);
+ err_fd = _fileno(stderr);
+ stdio_save_out_fd = _dup(out_fd);
+ stdio_save_err_fd = _dup(err_fd);
+ null_fd = _open( "NUL", _O_WRONLY );
+ _dup2(null_fd, out_fd);
+ _dup2(null_fd, err_fd);
+ close(null_fd);
+ }
+}
+
+extern void
+stdio_enable( void )
+{
+ if (--stdio_disable_count == 0) {
+ int out_fd, err_fd;
+ fflush(stdout);
+ out_fd = _fileno(stdout);
+ err_fd = _fileno(stderr);
+ _dup2(stdio_save_out_fd, out_fd);
+ _dup2(stdio_save_err_fd, err_fd);
+ _close(stdio_save_out_fd);
+ _close(stdio_save_err_fd);
+ }
+}
+#else
+extern void
+stdio_disable( void )
+{
+ if (++stdio_disable_count == 1) {
+ int null_fd, out_fd, err_fd;
+ fflush(stdout);
+ out_fd = fileno(stdout);
+ err_fd = fileno(stderr);
+ stdio_save_out_fd = dup(out_fd);
+ stdio_save_err_fd = dup(err_fd);
+ null_fd = open( "/dev/null", O_WRONLY );
+ dup2(null_fd, out_fd);
+ dup2(null_fd, err_fd);
+ close(null_fd);
+ }
+}
+
+extern void
+stdio_enable( void )
+{
+ if (--stdio_disable_count == 0) {
+ int out_fd, err_fd;
+ fflush(stdout);
+ out_fd = fileno(stdout);
+ err_fd = fileno(stderr);
+ dup2(stdio_save_out_fd, out_fd);
+ dup2(stdio_save_err_fd, err_fd);
+ close(stdio_save_out_fd);
+ close(stdio_save_err_fd);
+ }
+}
+#endif
diff --git a/android-emu/android/utils/debug.h b/android-emu/android/utils/debug.h
new file mode 100644
index 0000000..a6cdc02
--- /dev/null
+++ b/android-emu/android/utils/debug.h
@@ -0,0 +1,175 @@
+/* Copyright (C) 2007-2008 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+*/
+
+#pragma once
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "android/utils/compiler.h"
+
+ANDROID_BEGIN_HEADER
+
+#define VERBOSE_TAG_LIST \
+ _VERBOSE_TAG(init, "emulator initialization") \
+ _VERBOSE_TAG(console, "control console") \
+ _VERBOSE_TAG(modem, "emulated GSM modem") \
+ _VERBOSE_TAG(radio, "emulated GSM AT Command channel") \
+ _VERBOSE_TAG(keys, "key bindings & presses") \
+ _VERBOSE_TAG(events, "events sent to the emulator") \
+ _VERBOSE_TAG(slirp, "internal router/firewall") \
+ _VERBOSE_TAG(timezone, "host timezone detection") \
+ _VERBOSE_TAG(socket, "network sockets") \
+ _VERBOSE_TAG(proxy, "network proxy support") \
+ _VERBOSE_TAG(audio, "audio sub-system") \
+ _VERBOSE_TAG(audioin, "audio input backend") \
+ _VERBOSE_TAG(audioout, "audio output backend") \
+ _VERBOSE_TAG(surface, "video surface support") \
+ _VERBOSE_TAG(qemud, "qemud multiplexer daemon") \
+ _VERBOSE_TAG(gps, "emulated GPS") \
+ _VERBOSE_TAG(nand_limits, "nand/flash read/write thresholding") \
+ _VERBOSE_TAG(hw_control, "emulated power/flashlight/led/vibrator") \
+ _VERBOSE_TAG(avd_config, "android virtual device configuration") \
+ _VERBOSE_TAG(sensors, "emulated sensors") \
+ _VERBOSE_TAG(memcheck, "memory checker") \
+ _VERBOSE_TAG(camera, "camera") \
+ _VERBOSE_TAG(adevice, "android device connected via port forwarding") \
+ _VERBOSE_TAG(sensors_port, "sensors emulator connected to android device") \
+ _VERBOSE_TAG(mtport, "multi-touch emulator connected to android device") \
+ _VERBOSE_TAG(mtscreen, "multi-touch screen emulation") \
+ _VERBOSE_TAG(gles, "hardware OpenGLES emulation") \
+ _VERBOSE_TAG(gles1emu, "emulated GLESv1 renderer") \
+ _VERBOSE_TAG(adbserver, "ADB server") \
+ _VERBOSE_TAG(adbclient, "ADB QEMU client") \
+ _VERBOSE_TAG(adb, "ADB debugger") \
+ _VERBOSE_TAG(asconnector, "Asynchronous socket connector") \
+ _VERBOSE_TAG(asyncsocket, "Asynchronous socket") \
+ _VERBOSE_TAG(sdkctlsocket, "Socket tethering to SdkControl server") \
+ _VERBOSE_TAG(updater, "Update checker") \
+ _VERBOSE_TAG(metrics, "Metrics reporting") \
+ _VERBOSE_TAG(rotation, "Device rotation debugging") \
+ _VERBOSE_TAG(goldfishsync, "Goldfish Sync Device") \
+ _VERBOSE_TAG(syncthreads, "HostGPU Sync Threads") \
+ _VERBOSE_TAG(memory, "Memory Usage Report") \
+ _VERBOSE_TAG(car, "Emulated car data") \
+ _VERBOSE_TAG(record, "Screen recording") \
+ _VERBOSE_TAG(snapshot, "Snapshots") \
+ _VERBOSE_TAG(virtualscene, "Virtual scene rendering") \
+ _VERBOSE_TAG(automation, "Automation") \
+ _VERBOSE_TAG(offworld, "Offworld") \
+
+#define _VERBOSE_TAG(x,y) VERBOSE_##x,
+typedef enum {
+ VERBOSE_TAG_LIST
+ VERBOSE_MAX /* do not remove */
+} VerboseTag;
+#undef _VERBOSE_TAG
+
+extern uint64_t android_verbose;
+
+// Enable/disable verbose logs from the base/* family.
+extern void base_enable_verbose_logs();
+extern void base_disable_verbose_logs();
+
+#define VERBOSE_ENABLE(tag) \
+ android_verbose |= (1ULL << VERBOSE_##tag)
+
+#define VERBOSE_DISABLE(tag) \
+ android_verbose &= (1ULL << VERBOSE_##tag)
+
+#define VERBOSE_CHECK(tag) \
+ ((android_verbose & (1ULL << VERBOSE_##tag)) != 0)
+
+#define VERBOSE_CHECK_ANY() \
+ (android_verbose != 0)
+
+#define VERBOSE_PRINT(tag,...) \
+ do { if (VERBOSE_CHECK(tag)) dprint(__VA_ARGS__); } while (0)
+
+// This omits the "emulator: " prefix.
+#define VERBOSE_DPRINT(tag,format,...) \
+ do { if (VERBOSE_CHECK(tag)) { \
+ dprintn(format "\n", \
+ ##__VA_ARGS__); } } while(0)
+
+#define VERBOSE_FUNCTION_PRINT(tag,format,...) \
+ do { if (VERBOSE_CHECK(tag)) \
+ dprintn("emulator: %s: " format "\n", \
+ __func__, ##__VA_ARGS__); } while(0)
+
+// This omits the "emulator: " prefix.
+#define VERBOSE_FUNCTION_DPRINT(tag,format,...) \
+ do { if (VERBOSE_CHECK(tag)) \
+ dprintn("%s: " format "\n", \
+ __func__, ##__VA_ARGS__); } while(0)
+
+#define VERBOSE_TID_PRINT(tag,...) \
+ do { if (VERBOSE_CHECK(tag)) \
+ android_tid_function_print(true, NULL, __VA_ARGS__); \
+ } while (0)
+
+// This omits the "emulator: " prefix.
+#define VERBOSE_TID_DPRINT(tag,...) \
+ do { if (VERBOSE_CHECK(tag)) \
+ android_tid_function_print(false, NULL, __VA_ARGS__); } \
+ while (0)
+
+#define VERBOSE_TID_FUNCTION_PRINT(tag,...) \
+ do { if (VERBOSE_CHECK(tag)) \
+ android_tid_function_print(true, __func__, __VA_ARGS__); } \
+ while (0)
+
+// This omits the "emulator: " prefix.
+#define VERBOSE_TID_FUNCTION_DPRINT(tag,...) \
+ do { if (VERBOSE_CHECK(tag)) \
+ android_tid_function_print(false, __func__, __VA_ARGS__); } \
+ while (0)
+
+/** DEBUG TRACE SUPPORT
+ **
+ ** Debug messages can be sent by calling these functions:
+ **
+ ** 'dprint' prints "emulator: ", the message, then appends a '\n'
+ ** 'dprintn' prints the message as is
+ ** 'dprintnv' is 'dprintn' but allows you to use a va_list argument
+ ** 'dwarning' prints "emulator: WARNING: ", then appends a '\n'
+ ** 'derror' prints "emulator: ERROR: ", then appends a '\n'
+ */
+
+extern void dprint( const char* format, ... );
+extern void dprintn( const char* format, ... );
+extern void dprintnv( const char* format, va_list args );
+extern void dwarning( const char* format, ... );
+extern void derror( const char* format, ... );
+
+/** MULTITHREADED DEBUG TRACING
+ **
+ ** 'android_tid_function_print' is for tracing in multi-threaded situations.
+ ** It prints "emulator: " or not (depending on |use_emulator_prefix|),
+ ** the thread id, a function name (|function|), the message, and finally '\n'.
+ */
+extern void android_tid_function_print(bool use_emulator_prefix,
+ const char* function,
+ const char* format, ... );
+
+/** STDOUT/STDERR REDIRECTION
+ **
+ ** allows you to shut temporarily shutdown stdout/stderr
+ ** this is useful to get rid of debug messages from ALSA and esd
+ ** on Linux.
+ **/
+
+extern void stdio_disable( void );
+extern void stdio_enable( void );
+
+ANDROID_END_HEADER
diff --git a/cmake_transform.py b/cmake_transform.py
new file mode 100644
index 0000000..3e8d9c5
--- /dev/null
+++ b/cmake_transform.py
@@ -0,0 +1,190 @@
+#!/bin/python
+import argparse
+import hashlib
+import json
+import logging
+import os
+import sys
+
+
+def cleanup_json(data):
+ """Cleans up the json structure by removing empty "", and empty key value
+ pairs."""
+ if (isinstance(data, unicode)):
+ copy = data.strip()
+ return None if len(copy) == 0 else copy
+
+ if (isinstance(data, dict)):
+ copy = {}
+ for key, value in data.iteritems():
+ rem = cleanup_json(value)
+ if (rem is not None):
+ copy[key] = rem
+ return None if len(copy) == 0 else copy
+
+ if (isinstance(data, list)):
+ copy = []
+ for elem in data:
+ rem = cleanup_json(elem)
+ if (rem is not None):
+ if rem not in copy:
+ copy.append(rem)
+
+ if len(copy) == 0:
+ return None
+ return copy
+
+
+class AttrDict(dict):
+ def __init__(self, *args, **kwargs):
+ super(AttrDict, self).__init__(*args, **kwargs)
+ self.__dict__ = self
+
+ def as_list(self, name):
+ v = self.get(name, [])
+ if (isinstance(v, list)):
+ return v
+
+ return [v]
+
+
+def remove_lib_prefix(module):
+ """Removes the lib prefix, as we are not using them in CMake."""
+ if module.startswith('lib'):
+ return module[3:]
+ else:
+ return module
+
+
+def escape(msg):
+ """Escapes the "."""
+ return '"' + msg.replace('"', '\\"') + '"'
+
+
+def header():
+ """The auto generate header."""
+ return [
+ '# This is an autogenerated file! Do not edit!',
+ '# instead run make from .../device/generic/goldfish-opengl',
+ '# which will re-generate this file.'
+ ]
+
+
+def checksum(fname):
+ """Calculates a SHA256 digest of the given file name."""
+ m = hashlib.sha256()
+ with open(fname, 'r') as mk:
+ m.update(mk.read())
+ return m.hexdigest()
+
+
+def generate_module(module):
+ """Generates a cmake module."""
+ name = remove_lib_prefix(module['module'])
+ make = header()
+ mkfile = os.path.join(module['path'], 'Android.mk')
+ sha256 = checksum(mkfile)
+ make.append(
+ 'android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/%s" "%s")' % (mkfile, sha256))
+ make.append('set(%s_src %s)' % (name, ' '.join(module['src'])))
+ if module['type'] == 'SHARED_LIBRARY':
+ make.append('android_add_shared_library(%s)' % name)
+ elif module['type'] == 'STATIC_LIBRARY':
+ make.append('android_add_library(%s)' % name)
+ else:
+ raise ValueError('Unexpected module type: %s' % module['type'])
+
+ # Fix up the includes.
+ includes = ['${GOLDFISH_DEVICE_ROOT}/' + s for s in module['includes']]
+ make.append('target_include_directories(%s PRIVATE %s)' %
+ (name, ' '.join(includes)))
+
+ # filter out definitions
+ defs = [escape(d) for d in module['cflags'] if d.startswith('-D')]
+
+ # And the remaining flags.
+ flags = [escape(d) for d in module['cflags'] if not d.startswith('-D')]
+
+ # Make sure we remove the lib prefix from all our dependencies.
+ libs = [remove_lib_prefix(l) for l in module['libs']]
+ staticlibs = [remove_lib_prefix(l) for l in
+ module.get('staticlibs', [])
+ if l != "libandroidemu"]
+
+ # Configure the target.
+ make.append('target_compile_definitions(%s PRIVATE %s)' %
+ (name, ' '.join(defs)))
+ make.append('target_compile_options(%s PRIVATE %s)' %
+ (name, ' '.join(flags)))
+
+ if len(staticlibs) > 0:
+ make.append('target_link_libraries(%s PRIVATE %s PRIVATE %s)' %
+ (name, ' '.join(libs), " ".join(staticlibs)))
+ else:
+ make.append('target_link_libraries(%s PRIVATE %s)' %
+ (name, ' '.join(libs)))
+ return make
+
+
+def main(argv=None):
+ parser = argparse.ArgumentParser(
+ description='Generates a set of cmake files'
+ 'based up the js representation.'
+ 'Use this to generate cmake files that can be consumed by the emulator build')
+ parser.add_argument('-i', '--input', dest='input', type=str, required=True,
+ help='json file containing the build tree')
+ parser.add_argument('-v', '--verbose',
+ action='store_const', dest='loglevel',
+ const=logging.INFO, default=logging.ERROR,
+ help='Log what is happening')
+ parser.add_argument('-o', '--output',
+ dest='outdir', type=str, default=None,
+ help='Output directory for create CMakefile.txt')
+ parser.add_argument('-c', '--clean', dest='output', type=str,
+ default=None,
+ help='Write out the cleaned up js')
+ args = parser.parse_args()
+
+ logging.basicConfig(level=args.loglevel)
+
+ with open(args.input) as data_file:
+ data = json.load(data_file)
+
+ modules = cleanup_json(data)
+
+ # Write out cleaned up json, mainly useful for debugging etc.
+ if (args.output is not None):
+ with open(args.output, 'w') as out_file:
+ out_file.write(json.dumps(modules, indent=2))
+
+ # Location --> CMakeLists.txt
+ cmake = {}
+
+ # The root, it will basically just include all the generated files.
+ root = os.path.join(args.outdir, 'CMakeLists.txt')
+ mkfile = os.path.join(args.outdir, 'Android.mk')
+ sha256 = checksum(mkfile)
+ cmake[root] = header()
+ cmake[root].append('set(GOLDFISH_DEVICE_ROOT ${CMAKE_CURRENT_SOURCE_DIR})')
+ cmake[root].append(
+ 'android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/%s" "%s")' % (mkfile, sha256))
+
+ # Generate the modules.
+ for module in modules:
+ location = os.path.join(args.outdir, module['path'], 'CMakeLists.txt')
+
+ # Make sure we handle the case where we have >2 modules in the same dir.
+ if location not in cmake:
+ cmake[root].append('add_subdirectory(%s)' % module['path'])
+ cmake[location] = []
+ cmake[location].extend(generate_module(module))
+
+ # Write them to disk.
+ for (loc, cmklist) in cmake.iteritems():
+ logging.info('Writing to %s', loc)
+ with open(loc, 'w') as fn:
+ fn.write('\n'.join(cmklist))
+
+
+if __name__ == '__main__':
+ sys.exit(main())
diff --git a/common.mk b/common.mk
index c15812e..7991712 100644
--- a/common.mk
+++ b/common.mk
@@ -58,7 +58,8 @@
$(eval include $(_EMUGL_INCLUDE_TYPE))\
$(eval _EMUGL_INCLUDE_TYPE :=) \
$(eval _emugl_$(_emugl_HOST)modules += $(_emugl_MODULE))\
- $(if $(EMUGL_DEBUG),$(call emugl-dump-module))
+ $(if $(EMUGL_DEBUG),$(call emugl-dump-module)) \
+ $(if $(CMAKE_GENERATE), $(call dump-json-module))
# Managing module exports and imports.
#
diff --git a/host/include/libOpenglRender/IOStream.h b/host/include/libOpenglRender/IOStream.h
index 1d32ea1..d06440e 100644
--- a/host/include/libOpenglRender/IOStream.h
+++ b/host/include/libOpenglRender/IOStream.h
@@ -41,7 +41,7 @@
// NOTE: m_buf is 'owned' by the child class thus we expect it to be released by it
}
- unsigned char *alloc(size_t len) {
+ virtual unsigned char *alloc(size_t len) {
if (m_buf && len > m_free) {
if (flush() < 0) {
@@ -68,7 +68,7 @@
return ptr;
}
- int flush() {
+ virtual int flush() {
if (!m_buf || m_free == m_bufsize) return 0;
diff --git a/json-dump.mk b/json-dump.mk
new file mode 100644
index 0000000..2e20cdf
--- /dev/null
+++ b/json-dump.mk
@@ -0,0 +1,41 @@
+JSON_DUMP :=
+
+# Older versions of GNUmake do not support actual writing to file, so we sort of do what we can
+# and write out text in chunks, escaping "
+write-to-file = \
+ $(eval _args:=) \
+ $(foreach obj,$3,$(eval _args+=$(obj))$(if $(word $2,$(_args)),@printf "%s" $(subst ",\",$(_args)) >> $1 $(EOL)$(eval _args:=))) \
+ $(if $(_args),@printf "%s" $(subst ",\", $(_args)) >> $1) \
+
+define EOL
+
+
+endef
+
+# Functions to dump build information into a JSON tree.
+# This creates a [ "", "elem1", "elem2" ]
+dump-json-list = \
+ $(eval JSON_DUMP += [ "" ) \
+ $(if $(1),\
+ $(foreach _list_item,$(strip $1),$(eval JSON_DUMP += , "$(subst ",\",$(_list_item))")) \
+ ) \
+ $(eval JSON_DUMP += ] )\
+
+# This creates , "name" : ["", "e1", "e2" ]
+dump-property-list = \
+ $(eval JSON_DUMP += , "$(1)" : ) \
+ $(call dump-json-list, $($(2)))\
+
+# Dumps the module
+dump-json-module = \
+ $(eval JSON_DUMP += , { "module" : "$(_emugl_MODULE) ")\
+ $(eval JSON_DUMP += , "path" : "$(LOCAL_PATH) ")\
+ $(eval JSON_DUMP += , "type" : "$(_emugl.$(_emugl_MODULE).type)")\
+ $(call dump-property-list,includes,LOCAL_C_INCLUDES) \
+ $(call dump-property-list,cflags,LOCAL_CFLAGS) \
+ $(call dump-property-list,libs,LOCAL_SHARED_LIBRARIES) \
+ $(call dump-property-list,staticlibs,LOCAL_STATIC_LIBRARIES) \
+ $(call dump-property-list,src,LOCAL_SRC_FILES) \
+ $(eval JSON_DUMP += } )\
+
+
\ No newline at end of file
diff --git a/shared/OpenglCodecCommon/Android.mk b/shared/OpenglCodecCommon/Android.mk
index b9cf6e5..3971eae 100644
--- a/shared/OpenglCodecCommon/Android.mk
+++ b/shared/OpenglCodecCommon/Android.mk
@@ -12,14 +12,33 @@
IndexRangeCache.cpp \
SocketStream.cpp \
TcpStream.cpp \
+ auto_goldfish_dma_context.cpp \
+
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+commonSources += \
+ goldfish_dma_host.cpp \
+ qemu_pipe_host.cpp \
+
+else
+
+commonSources += \
+ goldfish_dma.cpp \
+
+endif
### CodecCommon guest ##############################################
-$(call emugl-begin-static-library,libOpenglCodecCommon)
+$(call emugl-begin-shared-library,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
LOCAL_SRC_FILES := $(commonSources)
LOCAL_CFLAGS += -DLOG_TAG=\"eglCodecCommon\"
$(call emugl-export,SHARED_LIBRARIES,libcutils libutils liblog)
+
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+$(call emugl-export,SHARED_LIBRARIES,android-emu-shared)
+endif
+
$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
$(call emugl-end-module)
diff --git a/shared/OpenglCodecCommon/CMakeLists.txt b/shared/OpenglCodecCommon/CMakeLists.txt
new file mode 100644
index 0000000..6f1f4ea
--- /dev/null
+++ b/shared/OpenglCodecCommon/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon/Android.mk" "b90bb271cb6f2c60c9d50bfe2a1273396e77e082d3482316f50185efdfb534c9")
+set(OpenglCodecCommon_host_src GLClientState.cpp GLESTextureUtils.cpp ChecksumCalculator.cpp GLSharedGroup.cpp glUtils.cpp IndexRangeCache.cpp SocketStream.cpp TcpStream.cpp auto_goldfish_dma_context.cpp goldfish_dma_host.cpp qemu_pipe_host.cpp)
+android_add_shared_library(OpenglCodecCommon_host)
+target_include_directories(OpenglCodecCommon_host PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(OpenglCodecCommon_host PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"eglCodecCommon\"")
+target_compile_options(OpenglCodecCommon_host PRIVATE "-fvisibility=default")
+target_link_libraries(OpenglCodecCommon_host PRIVATE android-emu-shared cutils utils log)
\ No newline at end of file
diff --git a/shared/OpenglCodecCommon/GLClientState.cpp b/shared/OpenglCodecCommon/GLClientState.cpp
index 7d40389..c4bf4da 100644
--- a/shared/OpenglCodecCommon/GLClientState.cpp
+++ b/shared/OpenglCodecCommon/GLClientState.cpp
@@ -1271,14 +1271,14 @@
res_info->rb_format = queryRboFormat(props.depthAttachment_rbo);
res_info->rb_multisamples =
queryRboSamples(
- props.colorAttachmenti_rbos[colorAttachmentIndex]);
+ props.depthAttachment_rbo);
} else if (props.depthAttachment_hasTexObj) {
res_info->type = FBO_ATTACHMENT_TEXTURE;
res_info->tex_internalformat = queryTexInternalFormat(props.depthAttachment_texture);
res_info->tex_format = queryTexFormat(props.depthAttachment_texture);
res_info->tex_type = queryTexType(props.depthAttachment_texture);
res_info->tex_multisamples =
- queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
+ queryTexSamples(props.depthAttachment_texture);
} else {
res_info->type = FBO_ATTACHMENT_NONE;
}
@@ -1289,14 +1289,14 @@
res_info->rb_format = queryRboFormat(props.stencilAttachment_rbo);
res_info->rb_multisamples =
queryRboSamples(
- props.colorAttachmenti_rbos[colorAttachmentIndex]);
+ props.stencilAttachment_rbo);
} else if (props.stencilAttachment_hasTexObj) {
res_info->type = FBO_ATTACHMENT_TEXTURE;
res_info->tex_internalformat = queryTexInternalFormat(props.stencilAttachment_texture);
res_info->tex_format = queryTexFormat(props.stencilAttachment_texture);
res_info->tex_type = queryTexType(props.stencilAttachment_texture);
res_info->tex_multisamples =
- queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
+ queryTexSamples(props.stencilAttachment_texture);
} else {
res_info->type = FBO_ATTACHMENT_NONE;
}
@@ -1307,14 +1307,14 @@
res_info->rb_format = queryRboFormat(props.depthstencilAttachment_rbo);
res_info->rb_multisamples =
queryRboSamples(
- props.colorAttachmenti_rbos[colorAttachmentIndex]);
+ props.depthstencilAttachment_rbo);
} else if (props.depthstencilAttachment_hasTexObj) {
res_info->type = FBO_ATTACHMENT_TEXTURE;
res_info->tex_internalformat = queryTexInternalFormat(props.depthstencilAttachment_texture);
res_info->tex_format = queryTexFormat(props.depthstencilAttachment_texture);
res_info->tex_type = queryTexType(props.depthstencilAttachment_texture);
res_info->tex_multisamples =
- queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
+ queryTexSamples(props.depthstencilAttachment_texture);
} else {
res_info->type = FBO_ATTACHMENT_NONE;
}
diff --git a/shared/OpenglCodecCommon/GLSharedGroup.cpp b/shared/OpenglCodecCommon/GLSharedGroup.cpp
index 19dfe0f..e4bc889 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.cpp
+++ b/shared/OpenglCodecCommon/GLSharedGroup.cpp
@@ -16,152 +16,157 @@
#include "GLSharedGroup.h"
-/**** KeyedVector utilities ****/
-
-template <typename T>
-static void clearObjectMap(android::DefaultKeyedVector<GLuint, T>& v) {
- for (size_t i = 0; i < v.size(); i++)
- delete v.valueAt(i);
- v.clear();
-}
+#include "KeyedVectorUtils.h"
/**** BufferData ****/
BufferData::BufferData() : m_size(0), m_usage(0), m_mapped(false) {};
-BufferData::BufferData(GLsizeiptr size, void * data) : m_size(size), m_usage(0), m_mapped(false)
-{
+
+BufferData::BufferData(GLsizeiptr size, const void* data) :
+ m_size(size), m_usage(0), m_mapped(false) {
+
void * buffer = NULL;
+
if (size>0) buffer = m_fixedBuffer.alloc(size);
+
if (data) memcpy(buffer, data, size);
}
/**** ProgramData ****/
ProgramData::ProgramData() : m_numIndexes(0),
m_initialized(false),
- m_locShiftWAR(false)
-{
+ m_locShiftWAR(false) {
m_Indexes = NULL;
}
-void ProgramData::initProgramData(GLuint numIndexes)
-{
+void ProgramData::initProgramData(GLuint numIndexes) {
m_initialized = true;
m_numIndexes = numIndexes;
- delete[] m_Indexes;
+
+ delete [] m_Indexes;
+
m_Indexes = new IndexInfo[numIndexes];
m_locShiftWAR = false;
}
-bool ProgramData::isInitialized()
-{
+bool ProgramData::isInitialized() {
return m_initialized;
}
-ProgramData::~ProgramData()
-{
- delete[] m_Indexes;
+ProgramData::~ProgramData() {
+
+ delete [] m_Indexes;
+
m_Indexes = NULL;
}
-void ProgramData::setIndexInfo(GLuint index, GLint base, GLint size, GLenum type)
-{
- if (index>=m_numIndexes)
- return;
+void ProgramData::setIndexInfo(
+ GLuint index, GLint base, GLint size, GLenum type) {
+
+ if (index >= m_numIndexes) return;
+
m_Indexes[index].base = base;
m_Indexes[index].size = size;
m_Indexes[index].type = type;
+
if (index > 0) {
m_Indexes[index].appBase = m_Indexes[index-1].appBase +
m_Indexes[index-1].size;
- }
- else {
+ } else {
m_Indexes[index].appBase = 0;
}
+
m_Indexes[index].hostLocsPerElement = 1;
m_Indexes[index].flags = 0;
m_Indexes[index].samplerValue = 0;
}
-void ProgramData::setIndexFlags(GLuint index, GLuint flags)
-{
- if (index >= m_numIndexes)
- return;
+void ProgramData::setIndexFlags(GLuint index, GLuint flags) {
+
+ if (index >= m_numIndexes) return;
+
m_Indexes[index].flags |= flags;
}
-GLuint ProgramData::getIndexForLocation(GLint location)
-{
+GLuint ProgramData::getIndexForLocation(GLint location) {
GLuint index = m_numIndexes;
+
GLint minDist = -1;
- for (GLuint i=0;i<m_numIndexes;++i)
- {
+
+ for (GLuint i = 0; i < m_numIndexes; ++i) {
GLint dist = location - m_Indexes[i].base;
- if (dist >= 0 &&
- (minDist < 0 || dist < minDist)) {
+ if (dist >= 0 && (minDist < 0 || dist < minDist)) {
index = i;
minDist = dist;
}
}
+
return index;
}
-GLenum ProgramData::getTypeForLocation(GLint location)
-{
+GLenum ProgramData::getTypeForLocation(GLint location) {
GLuint index = getIndexForLocation(location);
- if (index<m_numIndexes) {
+ if (index < m_numIndexes) {
return m_Indexes[index].type;
}
return 0;
}
-void ProgramData::setupLocationShiftWAR()
-{
+void ProgramData::setupLocationShiftWAR() {
m_locShiftWAR = false;
- for (GLuint i=0; i<m_numIndexes; i++) {
+ for (GLuint i= 0; i < m_numIndexes; i++) {
if (0 != (m_Indexes[i].base & 0xffff)) {
return;
}
}
+
// if we have one uniform at location 0, we do not need the WAR.
- if (m_numIndexes > 1) {
- m_locShiftWAR = true;
- }
+ if (m_numIndexes > 1) m_locShiftWAR = true;
}
-GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex)
-{
+GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex) {
+
if (!m_locShiftWAR) return hostLoc;
GLuint index = getIndexForLocation(hostLoc);
- if (index<m_numIndexes) {
+
+ if (index < m_numIndexes) {
if (arrIndex > 0) {
m_Indexes[index].hostLocsPerElement =
- (hostLoc - m_Indexes[index].base) / arrIndex;
+ (hostLoc - m_Indexes[index].base) / arrIndex;
}
return m_Indexes[index].appBase + arrIndex;
}
+
return -1;
}
-GLint ProgramData::locationWARAppToHost(GLint appLoc)
-{
+GLint ProgramData::locationWARAppToHost(GLint appLoc) {
+
if (!m_locShiftWAR) return appLoc;
- for(GLuint i=0; i<m_numIndexes; i++) {
- GLint elemIndex = appLoc - m_Indexes[i].appBase;
+ for (GLuint i = 0; i < m_numIndexes; i++) {
+ GLint elemIndex =
+ appLoc - m_Indexes[i].appBase;
+
if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
return m_Indexes[i].base +
elemIndex * m_Indexes[i].hostLocsPerElement;
}
}
+
return -1;
}
-GLint ProgramData::getNextSamplerUniform(GLint index, GLint* val, GLenum* target)
-{
+GLint ProgramData::getNextSamplerUniform(
+ GLint index, GLint* val, GLenum* target) {
+
for (GLint i = index + 1; i >= 0 && i < (GLint)m_numIndexes; i++) {
+
if (m_Indexes[i].type == GL_SAMPLER_2D) {
+
if (val) *val = m_Indexes[i].samplerValue;
+
if (target) {
if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) {
*target = GL_TEXTURE_EXTERNAL_OES;
@@ -169,16 +174,21 @@
*target = GL_TEXTURE_2D;
}
}
+
return i;
}
+
}
+
return -1;
}
-bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target)
-{
+bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target) {
+
for (GLuint i = 0; i < m_numIndexes; i++) {
+
GLint elemIndex = appLoc - m_Indexes[i].appBase;
+
if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
if (m_Indexes[i].type == GL_SAMPLER_2D) {
m_Indexes[i].samplerValue = val;
@@ -187,53 +197,47 @@
*target = GL_TEXTURE_EXTERNAL_OES;
} else {
*target = GL_TEXTURE_2D;
+
}
}
return true;
}
}
}
+
return false;
}
-bool ProgramData::attachShader(GLuint shader)
-{
+bool ProgramData::attachShader(GLuint shader) {
size_t n = m_shaders.size();
+
for (size_t i = 0; i < n; i++) {
if (m_shaders[i] == shader) {
return false;
}
}
- // AKA m_shaders.push_back(), but that has an ambiguous call to insertAt()
- // due to the default parameters. This is the desired insertAt() overload.
- m_shaders.insertAt(shader, m_shaders.size(), 1);
+ m_shaders.push_back(shader);
return true;
}
-bool ProgramData::detachShader(GLuint shader)
-{
+bool ProgramData::detachShader(GLuint shader) {
size_t n = m_shaders.size();
+
for (size_t i = 0; i < n; i++) {
if (m_shaders[i] == shader) {
- m_shaders.removeAt(i);
+ m_shaders.erase(m_shaders.begin() + i);
return true;
}
}
+
return false;
}
/***** GLSharedGroup ****/
-GLSharedGroup::GLSharedGroup() :
- m_buffers(android::DefaultKeyedVector<GLuint, BufferData*>(NULL)),
- m_programs(android::DefaultKeyedVector<GLuint, ProgramData*>(NULL)),
- m_shaders(android::DefaultKeyedVector<GLuint, ShaderData*>(NULL)),
- m_shaderPrograms(android::DefaultKeyedVector<GLuint, ShaderProgramData*>(NULL))
-{
-}
+GLSharedGroup::GLSharedGroup() { }
-GLSharedGroup::~GLSharedGroup()
-{
+GLSharedGroup::~GLSharedGroup() {
m_buffers.clear();
m_programs.clear();
clearObjectMap(m_buffers);
@@ -242,193 +246,227 @@
clearObjectMap(m_shaderPrograms);
}
-bool GLSharedGroup::isShaderOrProgramObject(GLuint obj)
-{
+bool GLSharedGroup::isShaderOrProgramObject(GLuint obj) {
+
android::AutoMutex _lock(m_lock);
- return ((m_shaders.valueFor(obj)!=NULL) ||
- (m_programs.valueFor(obj)!=NULL) ||
- (m_shaderPrograms.valueFor(m_shaderProgramIdMap[obj]) !=NULL));
+
+ return (findObjectOrDefault(m_shaders, obj) ||
+ findObjectOrDefault(m_programs, obj) ||
+ findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[obj]));
}
-BufferData * GLSharedGroup::getBufferData(GLuint bufferId)
-{
+BufferData* GLSharedGroup::getBufferData(GLuint bufferId) {
+
android::AutoMutex _lock(m_lock);
- return m_buffers.valueFor(bufferId);
+
+ return findObjectOrDefault(m_buffers, bufferId);
}
SharedTextureDataMap* GLSharedGroup::getTextureData() {
return &m_textureRecs;
}
-void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, void * data)
-{
+void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, const void* data) {
+
android::AutoMutex _lock(m_lock);
- m_buffers.add(bufferId, new BufferData(size, data));
+
+ m_buffers[bufferId] = new BufferData(size, data);
}
-void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, void * data)
-{
+void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, const void* data) {
+
android::AutoMutex _lock(m_lock);
- ssize_t idx = m_buffers.indexOfKey(bufferId);
- if (idx >= 0) {
- delete m_buffers.valueAt(idx);
- m_buffers.editValueAt(idx) = new BufferData(size, data);
- } else {
- m_buffers.add(bufferId, new BufferData(size, data));
- }
+
+ BufferData* currentBuffer = findObjectOrDefault(m_buffers, bufferId);
+
+ if (currentBuffer) delete currentBuffer;
+
+ m_buffers[bufferId] = new BufferData(size, data);
}
void GLSharedGroup::setBufferUsage(GLuint bufferId, GLenum usage) {
+
android::AutoMutex _lock(m_lock);
- ssize_t idx = m_buffers.indexOfKey(bufferId);
- if (idx >= 0) {
- m_buffers.editValueAt(idx)->m_usage = usage;
- }
+
+ BufferData* data = findObjectOrDefault(m_buffers, bufferId);
+
+ if (data) data->m_usage = usage;
}
void GLSharedGroup::setBufferMapped(GLuint bufferId, bool mapped) {
- BufferData * buf = m_buffers.valueFor(bufferId);
+ BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
if (!buf) return;
+
buf->m_mapped = mapped;
}
GLenum GLSharedGroup::getBufferUsage(GLuint bufferId) {
- BufferData * buf = m_buffers.valueFor(bufferId);
+ BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
if (!buf) return 0;
+
return buf->m_usage;
}
bool GLSharedGroup::isBufferMapped(GLuint bufferId) {
- BufferData * buf = m_buffers.valueFor(bufferId);
+ BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
if (!buf) return false;
+
return buf->m_mapped;
}
-GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data)
-{
- android::AutoMutex _lock(m_lock);
- BufferData * buf = m_buffers.valueFor(bufferId);
- if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) return GL_INVALID_VALUE;
+GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, const void* data) {
- //it's safe to update now
+ android::AutoMutex _lock(m_lock);
+
+ BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
+ if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) {
+ return GL_INVALID_VALUE;
+ }
+
memcpy((char*)buf->m_fixedBuffer.ptr() + offset, data, size);
buf->m_indexRangeCache.invalidateRange((size_t)offset, (size_t)size);
return GL_NO_ERROR;
}
-void GLSharedGroup::deleteBufferData(GLuint bufferId)
-{
+void GLSharedGroup::deleteBufferData(GLuint bufferId) {
+
android::AutoMutex _lock(m_lock);
- ssize_t idx = m_buffers.indexOfKey(bufferId);
- if (idx >= 0) {
- delete m_buffers.valueAt(idx);
- m_buffers.removeItemsAt(idx);
+
+ BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+ if (buf) {
+ delete buf;
+ m_buffers.erase(bufferId);
}
}
-void GLSharedGroup::addProgramData(GLuint program)
-{
+void GLSharedGroup::addProgramData(GLuint program) {
+
android::AutoMutex _lock(m_lock);
- ProgramData *pData = m_programs.valueFor(program);
- if (pData)
- {
- m_programs.removeItem(program);
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+ if (pData) {
delete pData;
}
- m_programs.add(program,new ProgramData());
+ m_programs[program] = new ProgramData();
}
-void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes)
-{
+void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes) {
+
android::AutoMutex _lock(m_lock);
- ProgramData *pData = m_programs.valueFor(program);
- if (pData)
- {
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+ if (pData) {
pData->initProgramData(numIndexes);
}
}
-bool GLSharedGroup::isProgramInitialized(GLuint program)
-{
+bool GLSharedGroup::isProgramInitialized(GLuint program) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
- if (pData)
- {
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+ if (pData) {
return pData->isInitialized();
}
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
- if (spData) {
- return spData->programData->isInitialized();
+
+ if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) {
+ return false;
}
+
+ ShaderProgramData* shaderProgramData =
+ findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+ if (shaderProgramData) {
+ return shaderProgramData->programData.isInitialized();
+ }
+
return false;
}
-void GLSharedGroup::deleteProgramData(GLuint program)
-{
- android::AutoMutex _lock(m_lock);
- ProgramData *pData = m_programs.valueFor(program);
- if (pData) {
- delete pData;
- }
- m_programs.removeItem(program);
+void GLSharedGroup::deleteProgramData(GLuint program) {
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
- if (spData) {
- delete spData;
- }
- m_shaderPrograms.removeItem(m_shaderProgramIdMap[program]);
+ android::AutoMutex _lock(m_lock);
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+ if (pData) delete pData;
+
+ m_programs.erase(program);
+
+ if (m_shaderProgramIdMap.find(program) ==
+ m_shaderProgramIdMap.end()) return;
+
+ ShaderProgramData* spData =
+ findObjectOrDefault(
+ m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+ if (spData) delete spData;
+
+ m_shaderPrograms.erase(m_shaderProgramIdMap[program]);
m_shaderProgramIdMap.erase(program);
}
// No such thing for separable shader programs.
-void GLSharedGroup::attachShader(GLuint program, GLuint shader)
-{
+void GLSharedGroup::attachShader(GLuint program, GLuint shader) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* programData = m_programs.valueFor(program);
- ssize_t idx = m_shaders.indexOfKey(shader);
- if (programData && idx >= 0) {
- if (programData->attachShader(shader)) {
- refShaderDataLocked(idx);
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+ ShaderData* sData = findObjectOrDefault(m_shaders, shader);
+
+ if (pData && sData) {
+ if (pData->attachShader(shader)) {
+ refShaderDataLocked(shader);
}
}
}
-void GLSharedGroup::detachShader(GLuint program, GLuint shader)
-{
+void GLSharedGroup::detachShader(GLuint program, GLuint shader) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* programData = m_programs.valueFor(program);
- ssize_t idx = m_shaders.indexOfKey(shader);
- if (programData && idx >= 0) {
- if (programData->detachShader(shader)) {
- unrefShaderDataLocked(idx);
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+ ShaderData* sData = findObjectOrDefault(m_shaders, shader);
+ if (pData && sData) {
+ if (pData->detachShader(shader)) {
+ unrefShaderDataLocked(shader);
}
}
}
// Not needed/used for separate shader programs.
-void GLSharedGroup::setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type, const char* name)
-{
- android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
- if (pData)
- {
- pData->setIndexInfo(index,base,size,type);
+void GLSharedGroup::setProgramIndexInfo(
+ GLuint program, GLuint index, GLint base,
+ GLint size, GLenum type, const char* name) {
+ android::AutoMutex _lock(m_lock);
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+ if (pData) {
+ pData->setIndexInfo(index,base,size,type);
if (type == GL_SAMPLER_2D) {
size_t n = pData->getNumShaders();
for (size_t i = 0; i < n; i++) {
GLuint shaderId = pData->getShader(i);
- ShaderData* shader = m_shaders.valueFor(shaderId);
+ ShaderData* shader = findObjectOrDefault(m_shaders, shaderId);
if (!shader) continue;
- ShaderData::StringList::iterator nameIter = shader->samplerExternalNames.begin();
- ShaderData::StringList::iterator nameEnd = shader->samplerExternalNames.end();
+ ShaderData::StringList::iterator nameIter =
+ shader->samplerExternalNames.begin();
+ ShaderData::StringList::iterator nameEnd =
+ shader->samplerExternalNames.end();
while (nameIter != nameEnd) {
if (*nameIter == name) {
- pData->setIndexFlags(index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
+ pData->setIndexFlags(
+ index,
+ ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
break;
}
++nameIter;
@@ -438,221 +476,319 @@
}
}
-GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location)
-{
+GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
- GLenum type=0;
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+ GLenum type = 0;
+
if (pData) {
type = pData->getTypeForLocation(location);
}
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return type;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
+
+ if (m_shaderProgramIdMap.find(program) ==
+ m_shaderProgramIdMap.end()) return type;
+
+ ShaderProgramData* spData =
+ findObjectOrDefault(
+ m_shaderPrograms, m_shaderProgramIdMap[program]);
+
if (spData) {
- type = spData->programData->getTypeForLocation(location);
+ type = spData->programData.getTypeForLocation(location);
}
+
return type;
}
-bool GLSharedGroup::isProgram(GLuint program)
-{
+bool GLSharedGroup::isProgram(GLuint program) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+
if (pData) return true;
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
+
+ if (m_shaderProgramIdMap.find(program) ==
+ m_shaderProgramIdMap.end()) return false;
+
+ ShaderProgramData* spData =
+ findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
if (spData) return true;
+
return false;
}
-void GLSharedGroup::setupLocationShiftWAR(GLuint program)
-{
+void GLSharedGroup::setupLocationShiftWAR(GLuint program) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
+
+ ProgramData* pData =
+ findObjectOrDefault(m_programs, program);
+
if (pData) pData->setupLocationShiftWAR();
}
-GLint GLSharedGroup::locationWARHostToApp(GLuint program, GLint hostLoc, GLint arrIndex)
-{
+GLint GLSharedGroup::locationWARHostToApp(
+ GLuint program, GLint hostLoc, GLint arrIndex) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+
if (pData) return pData->locationWARHostToApp(hostLoc, arrIndex);
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return hostLoc;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
- if (spData) return spData->programData->locationWARHostToApp(hostLoc, arrIndex);
+
+ if (m_shaderProgramIdMap.find(program) ==
+ m_shaderProgramIdMap.end()) return hostLoc;
+
+ ShaderProgramData* spData =
+ findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+ if (spData) return spData->programData.locationWARHostToApp(hostLoc, arrIndex);
+
return hostLoc;
}
-GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc)
-{
+GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
+
+ ProgramData* pData =
+ findObjectOrDefault(m_programs, program);
+
if (pData) return pData->locationWARAppToHost(appLoc);
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return appLoc;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
- if (spData) return spData->programData->locationWARAppToHost(appLoc);
+
+ if (m_shaderProgramIdMap.find(program) ==
+ m_shaderProgramIdMap.end()) return appLoc;
+
+ ShaderProgramData* spData =
+ findObjectOrDefault(
+ m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+ if (spData) return spData->programData.locationWARAppToHost(appLoc);
+
return appLoc;
}
-bool GLSharedGroup::needUniformLocationWAR(GLuint program)
-{
+bool GLSharedGroup::needUniformLocationWAR(GLuint program) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
+
+ ProgramData* pData =
+ findObjectOrDefault(m_programs, program);
+
if (pData) return pData->needUniformLocationWAR();
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
- if (spData) return spData->programData->needUniformLocationWAR();
+
+ if (m_shaderProgramIdMap.find(program) ==
+ m_shaderProgramIdMap.end()) return false;
+
+ ShaderProgramData* spData =
+ findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+ if (spData) return spData->programData.needUniformLocationWAR();
+
return false;
}
-GLint GLSharedGroup::getNextSamplerUniform(GLuint program, GLint index, GLint* val, GLenum* target) const
-{
+GLint GLSharedGroup::getNextSamplerUniform(
+ GLuint program, GLint index, GLint* val, GLenum* target) const {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
+
+ ProgramData* pData = findObjectOrDefault(m_programs, program);
+
if (pData) return pData->getNextSamplerUniform(index, val, target);
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return -1;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap.find(program)->second);
- if (spData) return spData->programData->getNextSamplerUniform(index, val, target);
+
+ if (m_shaderProgramIdMap.find(program) ==
+ m_shaderProgramIdMap.end()) return -1;
+
+ ShaderProgramData* spData =
+ findObjectOrDefault(
+ m_shaderPrograms,
+ findObjectOrDefault(m_shaderProgramIdMap, program));
+
+ if (spData) return spData->programData.getNextSamplerUniform(index, val, target);
+
return -1;
}
-bool GLSharedGroup::setSamplerUniform(GLuint program, GLint appLoc, GLint val, GLenum* target)
-{
+bool GLSharedGroup::setSamplerUniform(
+ GLuint program, GLint appLoc, GLint val, GLenum* target) {
+
android::AutoMutex _lock(m_lock);
- ProgramData* pData = m_programs.valueFor(program);
+
+ ProgramData* pData =
+ findObjectOrDefault(m_programs, program);
+
if (pData) return pData->setSamplerUniform(appLoc, val, target);
- if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
- ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
- if (spData) return spData->programData->setSamplerUniform(appLoc, val, target);
+
+ if (m_shaderProgramIdMap.find(program) ==
+ m_shaderProgramIdMap.end()) return false;
+
+ ShaderProgramData* spData =
+ findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+ if (spData) return spData->programData.setSamplerUniform(appLoc, val, target);
+
return false;
}
-bool GLSharedGroup::isShader(GLuint shader)
-{
+bool GLSharedGroup::isShader(GLuint shader) {
+
android::AutoMutex _lock(m_lock);
- ShaderData* pData = m_shaders.valueFor(shader);
- return (pData!=NULL);
+
+ ShaderData* pData = findObjectOrDefault(m_shaders, shader);
+
+ return pData != NULL;
}
-bool GLSharedGroup::addShaderData(GLuint shader)
-{
+bool GLSharedGroup::addShaderData(GLuint shader) {
+
android::AutoMutex _lock(m_lock);
+
ShaderData* data = new ShaderData;
+
if (data) {
- if (m_shaders.add(shader, data) < 0) {
- delete data;
- data = NULL;
- }
+ m_shaders[shader] = data;
data->refcount = 1;
}
+
return data != NULL;
}
-ShaderData* GLSharedGroup::getShaderData(GLuint shader)
-{
+ShaderData* GLSharedGroup::getShaderData(GLuint shader) {
+
android::AutoMutex _lock(m_lock);
- return m_shaders.valueFor(shader);
+
+ return findObjectOrDefault(m_shaders, shader);
}
-void GLSharedGroup::unrefShaderData(GLuint shader)
-{
+void GLSharedGroup::unrefShaderData(GLuint shader) {
+
android::AutoMutex _lock(m_lock);
- ssize_t idx = m_shaders.indexOfKey(shader);
- if (idx >= 0) {
- unrefShaderDataLocked(idx);
- }
+
+ unrefShaderDataLocked(shader);
}
-void GLSharedGroup::refShaderDataLocked(ssize_t shaderIdx)
-{
- assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size());
- ShaderData* data = m_shaders.valueAt(shaderIdx);
+void GLSharedGroup::refShaderDataLocked(GLuint shaderId) {
+ ShaderData* data = findObjectOrDefault(m_shaders, shaderId);
data->refcount++;
}
-void GLSharedGroup::unrefShaderDataLocked(ssize_t shaderIdx)
-{
- assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size());
- ShaderData* data = m_shaders.valueAt(shaderIdx);
- if (--data->refcount == 0) {
+void GLSharedGroup::unrefShaderDataLocked(GLuint shaderId) {
+ ShaderData* data = findObjectOrDefault(m_shaders, shaderId);
+
+ if (data && --data->refcount == 0) {
+
delete data;
- m_shaders.removeItemsAt(shaderIdx);
+
+ m_shaders.erase(shaderId);
}
}
uint32_t GLSharedGroup::addNewShaderProgramData() {
+
android::AutoMutex _lock(m_lock);
+
ShaderProgramData* data = new ShaderProgramData;
uint32_t currId = m_shaderProgramId;
+
ALOGD("%s: new data %p id %u", __FUNCTION__, data, currId);
- m_shaderPrograms.add(currId, data);
+
+ m_shaderPrograms[currId] = data;
m_shaderProgramId++;
return currId;
}
-void GLSharedGroup::associateGLShaderProgram(GLuint shaderProgramName, uint32_t shaderProgramId) {
+void GLSharedGroup::associateGLShaderProgram(
+ GLuint shaderProgramName, uint32_t shaderProgramId) {
+
android::AutoMutex _lock(m_lock);
+
m_shaderProgramIdMap[shaderProgramName] = shaderProgramId;
}
ShaderProgramData* GLSharedGroup::getShaderProgramDataById(uint32_t id) {
+
android::AutoMutex _lock(m_lock);
- ShaderProgramData* res = m_shaderPrograms.valueFor(id);
+
+ ShaderProgramData* res = findObjectOrDefault(m_shaderPrograms, id);
+
ALOGD("%s: id=%u res=%p", __FUNCTION__, id, res);
+
return res;
}
-ShaderProgramData* GLSharedGroup::getShaderProgramData(GLuint shaderProgramName) {
+ShaderProgramData* GLSharedGroup::getShaderProgramData(
+ GLuint shaderProgramName) {
+
android::AutoMutex _lock(m_lock);
- return m_shaderPrograms.valueFor(m_shaderProgramIdMap[shaderProgramName]);
+
+ return findObjectOrDefault(m_shaderPrograms,
+ m_shaderProgramIdMap[shaderProgramName]);
}
void GLSharedGroup::deleteShaderProgramDataById(uint32_t id) {
+
android::AutoMutex _lock(m_lock);
- ShaderProgramData* data = m_shaderPrograms.valueFor(id);
+
+ ShaderProgramData* data =
+ findObjectOrDefault(m_shaderPrograms, id);
+
delete data;
- m_shaderPrograms.removeItemsAt(id);
+
+ m_shaderPrograms.erase(id);
}
void GLSharedGroup::deleteShaderProgramData(GLuint shaderProgramName) {
+
android::AutoMutex _lock(m_lock);
+
uint32_t id = m_shaderProgramIdMap[shaderProgramName];
- ShaderProgramData* data = m_shaderPrograms.valueFor(id);
+ ShaderProgramData* data = findObjectOrDefault(m_shaderPrograms, id);
+
delete data;
- m_shaderPrograms.removeItemsAt(id);
+
+ m_shaderPrograms.erase(id);
m_shaderProgramIdMap.erase(shaderProgramName);
}
void GLSharedGroup::initShaderProgramData(GLuint shaderProgram, GLuint numIndices) {
ShaderProgramData* spData = getShaderProgramData(shaderProgram);
- spData->programData->initProgramData(numIndices);
+ spData->programData.initProgramData(numIndices);
}
-void GLSharedGroup::setShaderProgramIndexInfo(GLuint shaderProgram, GLuint index, GLint base, GLint size, GLenum type, const char* name) {
+void GLSharedGroup::setShaderProgramIndexInfo(
+ GLuint shaderProgram, GLuint index, GLint base,
+ GLint size, GLenum type, const char* name) {
+
ShaderProgramData* spData = getShaderProgramData(shaderProgram);
- ProgramData* pData = spData->programData;
- ShaderData* sData = spData->shaderData;
+ ProgramData& pData = spData->programData;
+ ShaderData& sData = spData->shaderData;
- if (pData)
- {
- pData->setIndexInfo(index, base, size, type);
+ pData.setIndexInfo(index, base, size, type);
- if (type == GL_SAMPLER_2D) {
- ShaderData::StringList::iterator nameIter = sData->samplerExternalNames.begin();
- ShaderData::StringList::iterator nameEnd = sData->samplerExternalNames.end();
- while (nameIter != nameEnd) {
- if (*nameIter == name) {
- pData->setIndexFlags(index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
- break;
- }
- ++nameIter;
+ if (type == GL_SAMPLER_2D) {
+
+ ShaderData::StringList::iterator nameIter =
+ sData.samplerExternalNames.begin();
+ ShaderData::StringList::iterator nameEnd =
+ sData.samplerExternalNames.end();
+
+ while (nameIter != nameEnd) {
+ if (*nameIter == name) {
+ pData.setIndexFlags(
+ index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
+ break;
}
+ ++nameIter;
}
}
}
void GLSharedGroup::setupShaderProgramLocationShiftWAR(GLuint shaderProgram) {
ShaderProgramData* spData = getShaderProgramData(shaderProgram);
- spData->programData->setupLocationShiftWAR();
+ spData->programData.setupLocationShiftWAR();
}
diff --git a/shared/OpenglCodecCommon/GLSharedGroup.h b/shared/OpenglCodecCommon/GLSharedGroup.h
index ca33836..9ef92ea 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.h
+++ b/shared/OpenglCodecCommon/GLSharedGroup.h
@@ -36,17 +36,15 @@
#include <stdio.h>
#include <stdlib.h>
#include "ErrorLog.h"
-#include <utils/KeyedVector.h>
-#include <utils/List.h>
-#include <utils/String8.h>
#include <utils/threads.h>
#include "FixedBuffer.h"
+#include "auto_goldfish_dma_context.h"
#include "IndexRangeCache.h"
#include "SmartPtr.h"
struct BufferData {
BufferData();
- BufferData(GLsizeiptr size, void * data);
+ BufferData(GLsizeiptr size, const void* data);
// General buffer state
GLsizeiptr m_size;
@@ -57,10 +55,14 @@
GLbitfield m_mappedAccess;
GLintptr m_mappedOffset;
GLsizeiptr m_mappedLength;
+ uint64_t m_guest_paddr;
// Internal bookkeeping
FixedBuffer m_fixedBuffer; // actual buffer is shadowed here
IndexRangeCache m_indexRangeCache;
+
+ // DMA support
+ AutoGoldfishDmaContext dma_buffer;
};
class ProgramData {
@@ -80,7 +82,7 @@
bool m_initialized;
bool m_locShiftWAR;
- android::Vector<GLuint> m_shaders;
+ std::vector<GLuint> m_shaders;
public:
enum {
@@ -111,7 +113,7 @@
};
struct ShaderData {
- typedef android::List<android::String8> StringList;
+ typedef std::vector<std::string> StringList;
StringList samplerExternalNames;
int refcount;
std::vector<std::string> sources;
@@ -119,31 +121,23 @@
class ShaderProgramData {
public:
- ShaderProgramData() {
- shaderData = new ShaderData();
- programData = new ProgramData();
- }
- ~ShaderProgramData() {
- delete shaderData;
- delete programData;
- }
- ShaderData* shaderData;
- ProgramData* programData;
+ ShaderData shaderData;
+ ProgramData programData;
};
class GLSharedGroup {
private:
SharedTextureDataMap m_textureRecs;
- android::DefaultKeyedVector<GLuint, BufferData*> m_buffers;
- android::DefaultKeyedVector<GLuint, ProgramData*> m_programs;
- android::DefaultKeyedVector<GLuint, ShaderData*> m_shaders;
- android::DefaultKeyedVector<uint32_t, ShaderProgramData*> m_shaderPrograms;
+ std::map<GLuint, BufferData*> m_buffers;
+ std::map<GLuint, ProgramData*> m_programs;
+ std::map<GLuint, ShaderData*> m_shaders;
+ std::map<uint32_t, ShaderProgramData*> m_shaderPrograms;
std::map<GLuint, uint32_t> m_shaderProgramIdMap;
mutable android::Mutex m_lock;
- void refShaderDataLocked(ssize_t shaderIdx);
- void unrefShaderDataLocked(ssize_t shaderIdx);
+ void refShaderDataLocked(GLuint shader);
+ void unrefShaderDataLocked(GLuint shader);
uint32_t m_shaderProgramId;
@@ -153,13 +147,13 @@
bool isShaderOrProgramObject(GLuint obj);
BufferData * getBufferData(GLuint bufferId);
SharedTextureDataMap* getTextureData();
- void addBufferData(GLuint bufferId, GLsizeiptr size, void * data);
- void updateBufferData(GLuint bufferId, GLsizeiptr size, void * data);
+ void addBufferData(GLuint bufferId, GLsizeiptr size, const void* data);
+ void updateBufferData(GLuint bufferId, GLsizeiptr size, const void* data);
void setBufferUsage(GLuint bufferId, GLenum usage);
void setBufferMapped(GLuint bufferId, bool mapped);
GLenum getBufferUsage(GLuint bufferId);
bool isBufferMapped(GLuint bufferId);
- GLenum subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data);
+ GLenum subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, const void* data);
void deleteBufferData(GLuint);
bool isProgram(GLuint program);
diff --git a/shared/OpenglCodecCommon/IndexRangeCache.cpp b/shared/OpenglCodecCommon/IndexRangeCache.cpp
index c94e70c..4a73d22 100644
--- a/shared/OpenglCodecCommon/IndexRangeCache.cpp
+++ b/shared/OpenglCodecCommon/IndexRangeCache.cpp
@@ -57,12 +57,7 @@
size_t invalidateStart = offset;
size_t invalidateEnd = offset + size;
- IndexRangeMap::iterator it =
- mIndexRangeCache.lower_bound(
- IndexRangeKey(GL_UNSIGNED_BYTE,
- offset,
- size,
- false));
+ IndexRangeMap::iterator it = mIndexRangeCache.begin();
while (it != mIndexRangeCache.end()) {
size_t rangeStart = it->first.offset;
diff --git a/shared/OpenglCodecCommon/IndexRangeCache.h b/shared/OpenglCodecCommon/IndexRangeCache.h
index 5f77958..4db2c56 100644
--- a/shared/OpenglCodecCommon/IndexRangeCache.h
+++ b/shared/OpenglCodecCommon/IndexRangeCache.h
@@ -75,15 +75,12 @@
primitiveRestartEnabled(_primitiveRestart) { }
bool operator<(const IndexRangeKey& rhs) const {
- size_t start_other = rhs.offset;
size_t end = offset + count * glSizeof(type);
+ size_t end_other = rhs.offset + rhs.count * glSizeof(rhs.type);
- if (end <= start_other) {
- return true;
- }
-
+ if (offset != rhs.offset) return offset < rhs.offset;
+ if (end != end_other) return end < end_other;
if (type != rhs.type) return type < rhs.type;
- if (count != rhs.count) return count < rhs.count;
if (primitiveRestartEnabled != rhs.primitiveRestartEnabled)
return primitiveRestartEnabled;
return false;
diff --git a/shared/OpenglCodecCommon/KeyedVectorUtils.h b/shared/OpenglCodecCommon/KeyedVectorUtils.h
new file mode 100644
index 0000000..97dc9f1
--- /dev/null
+++ b/shared/OpenglCodecCommon/KeyedVectorUtils.h
@@ -0,0 +1,38 @@
+/*
+* Copyright (C) 2018 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#pragma once
+
+#include <map>
+
+template <typename T>
+void clearObjectMap(std::map<GLuint, T>& v) {
+ typename std::map<GLuint, T>::iterator it = v.begin();
+ for (; it != v.end(); ++it) {
+ delete it->second;
+ }
+ v.clear();
+}
+
+template <typename K, typename V>
+V findObjectOrDefault(const std::map<K, V>& m, K key, V defaultValue = 0) {
+ typename std::map<K, V>::const_iterator it = m.find(key);
+
+ if (it == m.end()) {
+ return defaultValue;
+ }
+
+ return it->second;
+}
diff --git a/shared/OpenglCodecCommon/PortableMutex.h b/shared/OpenglCodecCommon/PortableMutex.h
new file mode 100644
index 0000000..b02ed61
--- /dev/null
+++ b/shared/OpenglCodecCommon/PortableMutex.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2007 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
+
+// TODO: switch to <mutex> and std::mutex when this code no longer needs
+// to compile for pre-C++11...
+
+#include <sys/types.h>
+
+#if !defined(_WIN32)
+#include <pthread.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_WIN32)
+
+typedef pthread_mutex_t mutex_t;
+
+static __inline__ void mutex_lock(mutex_t* lock) {
+ pthread_mutex_lock(lock);
+}
+
+static __inline__ void mutex_unlock(mutex_t* lock) {
+ pthread_mutex_unlock(lock);
+}
+
+static __inline__ int mutex_init(mutex_t* lock) {
+ return pthread_mutex_init(lock, NULL);
+}
+
+static __inline__ void mutex_destroy(mutex_t* lock) {
+ pthread_mutex_destroy(lock);
+}
+
+#else // !defined(_WIN32)
+
+typedef struct {
+ int init;
+ CRITICAL_SECTION lock[1];
+} mutex_t;
+
+#define MUTEX_INITIALIZER { 0, {{ NULL, 0, 0, NULL, NULL, 0 }} }
+
+static __inline__ void mutex_lock(mutex_t* lock) {
+ if (!lock->init) {
+ lock->init = 1;
+ InitializeCriticalSection( lock->lock );
+ lock->init = 2;
+ } else while (lock->init != 2) {
+ Sleep(10);
+ }
+ EnterCriticalSection(lock->lock);
+}
+
+static __inline__ void mutex_unlock(mutex_t* lock) {
+ LeaveCriticalSection(lock->lock);
+}
+
+static __inline__ int mutex_init(mutex_t* lock) {
+ InitializeCriticalSection(lock->lock);
+ lock->init = 2;
+ return 0;
+}
+
+static __inline__ void mutex_destroy(mutex_t* lock) {
+ if (lock->init) {
+ lock->init = 0;
+ DeleteCriticalSection(lock->lock);
+ }
+}
+
+#endif // !defined(_WIN32)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/shared/OpenglCodecCommon/SmartPtr.h b/shared/OpenglCodecCommon/SmartPtr.h
index 4bdfbe4..3d821c8 100644
--- a/shared/OpenglCodecCommon/SmartPtr.h
+++ b/shared/OpenglCodecCommon/SmartPtr.h
@@ -16,7 +16,8 @@
#ifndef __SMART_PTR_H
#define __SMART_PTR_H
-#include <cutils/threads.h>
+#include <PortableMutex.h>
+
#include <cutils/atomic.h>
template <class T, bool threadSafe = false>
diff --git a/shared/OpenglCodecCommon/auto_goldfish_dma_context.cpp b/shared/OpenglCodecCommon/auto_goldfish_dma_context.cpp
new file mode 100644
index 0000000..280262d
--- /dev/null
+++ b/shared/OpenglCodecCommon/auto_goldfish_dma_context.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2018 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include "auto_goldfish_dma_context.h"
+
+namespace {
+goldfish_dma_context empty() {
+ goldfish_dma_context ctx;
+
+ ctx.mapped_addr = 0;
+ ctx.size = 0;
+ ctx.fd = -1;
+
+ return ctx;
+}
+
+void destroy(goldfish_dma_context *ctx) {
+ if (ctx->mapped_addr) {
+ goldfish_dma_unmap(ctx);
+ }
+ if (ctx->fd > 0) {
+ goldfish_dma_free(ctx);
+ }
+}
+} // namespace
+
+AutoGoldfishDmaContext::AutoGoldfishDmaContext() : m_ctx(empty()) {}
+
+AutoGoldfishDmaContext::AutoGoldfishDmaContext(goldfish_dma_context *ctx)
+ : m_ctx(*ctx) {
+ *ctx = empty();
+}
+
+AutoGoldfishDmaContext::~AutoGoldfishDmaContext() {
+ destroy(&m_ctx);
+}
+
+void AutoGoldfishDmaContext::reset(goldfish_dma_context *ctx) {
+ destroy(&m_ctx);
+ if (ctx) {
+ m_ctx = *ctx;
+ *ctx = empty();
+ } else {
+ m_ctx = empty();
+ }
+}
+
+goldfish_dma_context AutoGoldfishDmaContext::release() {
+ goldfish_dma_context copy = m_ctx;
+ m_ctx = empty();
+ return copy;
+}
+
diff --git a/shared/OpenglCodecCommon/auto_goldfish_dma_context.h b/shared/OpenglCodecCommon/auto_goldfish_dma_context.h
new file mode 100644
index 0000000..7d97fc2
--- /dev/null
+++ b/shared/OpenglCodecCommon/auto_goldfish_dma_context.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2018 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef ANDROID_INCLUDE_HARDWARE_AUTO_GOLDFISH_DMA_CONTEXT_H
+#define ANDROID_INCLUDE_HARDWARE_AUTO_GOLDFISH_DMA_CONTEXT_H
+
+#include <inttypes.h>
+#include "goldfish_dma.h"
+
+// A C++ wrapper for goldfish_dma_context that releases resources in dctor.
+class AutoGoldfishDmaContext {
+public:
+ AutoGoldfishDmaContext();
+ explicit AutoGoldfishDmaContext(goldfish_dma_context *ctx);
+ ~AutoGoldfishDmaContext();
+
+ const goldfish_dma_context &get() const { return m_ctx; }
+ void reset(goldfish_dma_context *ctx);
+ goldfish_dma_context release();
+
+private:
+ AutoGoldfishDmaContext(const AutoGoldfishDmaContext &rhs);
+ AutoGoldfishDmaContext& operator=(const AutoGoldfishDmaContext &rhs);
+
+ goldfish_dma_context m_ctx;
+};
+
+#endif // ANDROID_INCLUDE_HARDWARE_AUTO_GOLDFISH_DMA_CONTEXT_H
diff --git a/shared/OpenglCodecCommon/glUtils.h b/shared/OpenglCodecCommon/glUtils.h
index 2210699..e1f4ff3 100644
--- a/shared/OpenglCodecCommon/glUtils.h
+++ b/shared/OpenglCodecCommon/glUtils.h
@@ -16,6 +16,8 @@
#ifndef __GL_UTILS_H__
#define __GL_UTILS_H__
+#include <cutils/log.h>
+
#include <stdio.h>
#include <stdlib.h>
diff --git a/system/OpenglSystemCommon/goldfish_dma.cpp b/shared/OpenglCodecCommon/goldfish_dma.cpp
similarity index 76%
rename from system/OpenglSystemCommon/goldfish_dma.cpp
rename to shared/OpenglCodecCommon/goldfish_dma.cpp
index 046367d..36fa2ae 100644
--- a/system/OpenglSystemCommon/goldfish_dma.cpp
+++ b/shared/OpenglCodecCommon/goldfish_dma.cpp
@@ -16,10 +16,34 @@
#include "qemu_pipe.h"
#include <cutils/log.h>
+#include <errno.h>
+#include <linux/ioctl.h>
+#include <linux/types.h>
+#include <sys/cdefs.h>
#include <sys/mman.h>
+#include <fcntl.h>
+#include <stdlib.h>
#include <stdlib.h>
#include <string.h>
+/* There is an ioctl associated with goldfish dma driver.
+ * Make it conflict with ioctls that are not likely to be used
+ * in the emulator.
+ * 'G' 00-3F drivers/misc/sgi-gru/grulib.h conflict!
+ * 'G' 00-0F linux/gigaset_dev.h conflict!
+ */
+#define GOLDFISH_DMA_IOC_MAGIC 'G'
+
+#define GOLDFISH_DMA_IOC_LOCK _IOWR(GOLDFISH_DMA_IOC_MAGIC, 0, struct goldfish_dma_ioctl_info)
+#define GOLDFISH_DMA_IOC_UNLOCK _IOWR(GOLDFISH_DMA_IOC_MAGIC, 1, struct goldfish_dma_ioctl_info)
+#define GOLDFISH_DMA_IOC_GETOFF _IOWR(GOLDFISH_DMA_IOC_MAGIC, 2, struct goldfish_dma_ioctl_info)
+#define GOLDFISH_DMA_IOC_CREATE_REGION _IOWR(GOLDFISH_DMA_IOC_MAGIC, 3, struct goldfish_dma_ioctl_info)
+
+struct goldfish_dma_ioctl_info {
+ uint64_t phys_begin;
+ uint64_t size;
+};
+
int goldfish_dma_lock(struct goldfish_dma_context* cxt) {
struct goldfish_dma_ioctl_info info;
@@ -97,7 +121,7 @@
close(cxt->fd);
}
-uint64_t goldfish_dma_guest_paddr(struct goldfish_dma_context* cxt) {
+uint64_t goldfish_dma_guest_paddr(const struct goldfish_dma_context* cxt) {
struct goldfish_dma_ioctl_info info;
ioctl(cxt->fd, GOLDFISH_DMA_IOC_GETOFF, &info);
return info.phys_begin;
diff --git a/shared/OpenglCodecCommon/goldfish_dma.h b/shared/OpenglCodecCommon/goldfish_dma.h
new file mode 100644
index 0000000..db1e8d6
--- /dev/null
+++ b/shared/OpenglCodecCommon/goldfish_dma.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef ANDROID_INCLUDE_HARDWARE_GOLDFISH_DMA_H
+#define ANDROID_INCLUDE_HARDWARE_GOLDFISH_DMA_H
+
+#include <inttypes.h>
+
+// userspace interface
+struct goldfish_dma_context {
+ uint64_t mapped_addr;
+ uint32_t size;
+ int32_t fd;
+};
+
+int goldfish_dma_lock(struct goldfish_dma_context* cxt);
+int goldfish_dma_unlock(struct goldfish_dma_context* cxt);
+int goldfish_dma_create_region(uint32_t sz, struct goldfish_dma_context* res);
+
+void* goldfish_dma_map(struct goldfish_dma_context* cxt);
+int goldfish_dma_unmap(struct goldfish_dma_context* cxt);
+
+void goldfish_dma_write(struct goldfish_dma_context* cxt,
+ const void* to_write,
+ uint32_t sz);
+
+void goldfish_dma_free(goldfish_dma_context* cxt);
+uint64_t goldfish_dma_guest_paddr(const struct goldfish_dma_context* cxt);
+
+#endif
diff --git a/shared/OpenglCodecCommon/goldfish_dma_host.cpp b/shared/OpenglCodecCommon/goldfish_dma_host.cpp
new file mode 100644
index 0000000..93dcfa3
--- /dev/null
+++ b/shared/OpenglCodecCommon/goldfish_dma_host.cpp
@@ -0,0 +1,47 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "goldfish_dma.h"
+
+int goldfish_dma_lock(struct goldfish_dma_context* cxt) {
+ return 0;
+}
+
+int goldfish_dma_unlock(struct goldfish_dma_context* cxt) {
+ return 0;
+}
+
+int goldfish_dma_create_region(uint32_t sz, struct goldfish_dma_context* res) {
+ return 0;
+}
+
+void* goldfish_dma_map(struct goldfish_dma_context* cxt) {
+ return 0;
+}
+
+int goldfish_dma_unmap(struct goldfish_dma_context* cxt) {
+ return 0;
+}
+
+void goldfish_dma_write(struct goldfish_dma_context* cxt,
+ const void* to_write,
+ uint32_t sz) {
+}
+
+void goldfish_dma_free(goldfish_dma_context* cxt) {
+}
+
+uint64_t goldfish_dma_guest_paddr(const struct goldfish_dma_context* cxt) {
+ return 0;
+}
+
diff --git a/system/OpenglSystemCommon/gralloc_cb.h b/shared/OpenglCodecCommon/gralloc_cb.h
similarity index 91%
rename from system/OpenglSystemCommon/gralloc_cb.h
rename to shared/OpenglCodecCommon/gralloc_cb.h
index 04a7040..f874c12 100644
--- a/system/OpenglSystemCommon/gralloc_cb.h
+++ b/shared/OpenglCodecCommon/gralloc_cb.h
@@ -22,6 +22,7 @@
#include <cutils/native_handle.h>
#include "goldfish_dma.h"
+#include "qemu_pipe.h"
#define BUFFER_HANDLE_MAGIC ((int)0xabfabfab)
#define CB_HANDLE_NUM_INTS(nfds) (int)((sizeof(cb_handle_t) - (nfds)*sizeof(int)) / sizeof(int))
@@ -64,7 +65,7 @@
emuFrameworkFormat(p_emuFrameworkFormat)
{
goldfish_dma.fd = -1;
- dmafd = -1;
+ refcount_pipe_fd = QEMU_PIPE_INVALID_HANDLE;
version = sizeof(native_handle);
numFds = 0;
numInts = CB_HANDLE_NUM_INTS(numFds);
@@ -82,11 +83,15 @@
numInts = CB_HANDLE_NUM_INTS(numFds);
}
- void setDmaFd(int fd) {
- if (fd >= 0) {
+ bool hasRefcountPipe() {
+ return qemu_pipe_valid(refcount_pipe_fd);
+ }
+
+ void setRefcountPipeFd(QEMU_PIPE_HANDLE fd) {
+ if (qemu_pipe_valid(fd)) {
numFds++;
}
- dmafd = fd;
+ refcount_pipe_fd = fd;
numInts = CB_HANDLE_NUM_INTS(numFds);
}
@@ -103,7 +108,7 @@
// file-descriptors
int fd; // ashmem fd (-1 of ashmem region did not allocated, i.e. no SW access needed)
- int dmafd; // goldfish dma fd.
+ QEMU_PIPE_HANDLE refcount_pipe_fd; // goldfish pipe service for gralloc refcounting fd.
// ints
int magic; // magic number in order to validate a pointer to be a cb_handle_t
diff --git a/system/OpenglSystemCommon/qemu_pipe.h b/shared/OpenglCodecCommon/qemu_pipe.h
similarity index 66%
rename from system/OpenglSystemCommon/qemu_pipe.h
rename to shared/OpenglCodecCommon/qemu_pipe.h
index 52f4ee7..62de57f 100644
--- a/system/OpenglSystemCommon/qemu_pipe.h
+++ b/shared/OpenglCodecCommon/qemu_pipe.h
@@ -16,6 +16,32 @@
#ifndef ANDROID_INCLUDE_HARDWARE_QEMU_PIPE_H
#define ANDROID_INCLUDE_HARDWARE_QEMU_PIPE_H
+#ifdef HOST_BUILD
+
+#include <sys/types.h>
+
+typedef void* QEMU_PIPE_HANDLE;
+
+#define QEMU_PIPE_INVALID_HANDLE NULL
+
+QEMU_PIPE_HANDLE qemu_pipe_open(const char* pipeName);
+void qemu_pipe_close(QEMU_PIPE_HANDLE pipe);
+
+ssize_t qemu_pipe_read(QEMU_PIPE_HANDLE pipe, void* buffer, size_t len);
+ssize_t qemu_pipe_write(QEMU_PIPE_HANDLE pipe, const void* buffer, size_t len);
+
+bool qemu_pipe_try_again();
+bool qemu_pipe_valid(QEMU_PIPE_HANDLE pipe);
+
+void qemu_pipe_print_error(QEMU_PIPE_HANDLE pipe);
+
+#else
+
+typedef int QEMU_PIPE_HANDLE;
+
+#define QEMU_PIPE_INVALID_HANDLE (-1)
+
+#include <cutils/log.h>
#include <sys/cdefs.h>
#include <unistd.h>
#include <fcntl.h>
@@ -30,7 +56,7 @@
# define D(...) do{}while(0)
#endif
-static bool WriteFully(int fd, const void* data, size_t byte_count) {
+static bool WriteFully(QEMU_PIPE_HANDLE fd, const void* data, size_t byte_count) {
const uint8_t* p = (const uint8_t*)(data);
size_t remaining = byte_count;
while (remaining > 0) {
@@ -64,12 +90,11 @@
* except for a few special cases (e.g. GSM modem), where EBUSY will be
* returned if more than one client tries to connect to it.
*/
-static __inline__ int
-qemu_pipe_open(const char* pipeName)
-{
+static __inline__ QEMU_PIPE_HANDLE
+qemu_pipe_open(const char* pipeName) {
char buff[256];
int buffLen;
- int fd;
+ QEMU_PIPE_HANDLE fd;
if (pipeName == NULL || pipeName[0] == '\0') {
errno = EINVAL;
@@ -97,4 +122,36 @@
return fd;
}
+static __inline__ void
+qemu_pipe_close(QEMU_PIPE_HANDLE pipe) {
+ close(pipe);
+}
+
+static __inline__ ssize_t
+qemu_pipe_read(QEMU_PIPE_HANDLE pipe, void* buffer, size_t len) {
+ return read(pipe, buffer, len);
+}
+
+static __inline__ ssize_t
+qemu_pipe_write(QEMU_PIPE_HANDLE pipe, const void* buffer, size_t len) {
+ return write(pipe, buffer, len);
+}
+
+static __inline__ bool
+qemu_pipe_try_again() {
+ return errno == EINTR;
+}
+
+static __inline__ bool
+qemu_pipe_valid(QEMU_PIPE_HANDLE pipe) {
+ return pipe >= 0;
+}
+
+static __inline__ void
+qemu_pipe_print_error(QEMU_PIPE_HANDLE pipe) {
+ ALOGE("pipe error: fd %d errno %d", pipe, errno);
+}
+
+#endif // !HOST_BUILD
+
#endif /* ANDROID_INCLUDE_HARDWARE_QEMU_PIPE_H */
diff --git a/shared/OpenglCodecCommon/qemu_pipe_host.cpp b/shared/OpenglCodecCommon/qemu_pipe_host.cpp
new file mode 100644
index 0000000..b4dc2af
--- /dev/null
+++ b/shared/OpenglCodecCommon/qemu_pipe_host.cpp
@@ -0,0 +1,50 @@
+// 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 "qemu_pipe.h"
+
+#include "android/emulation/hostpipe/HostGoldfishPipe.h"
+
+#include <cutils/log.h>
+
+using android::HostGoldfishPipeDevice;
+
+QEMU_PIPE_HANDLE qemu_pipe_open(const char* pipeName) {
+ return HostGoldfishPipeDevice::get()->connect(pipeName);
+}
+
+void qemu_pipe_close(QEMU_PIPE_HANDLE pipe) {
+ HostGoldfishPipeDevice::get()->close(pipe);
+}
+
+ssize_t qemu_pipe_read(QEMU_PIPE_HANDLE pipe, void* buffer, size_t len) {
+ return HostGoldfishPipeDevice::get()->read(pipe, buffer, len);
+}
+
+ssize_t qemu_pipe_write(QEMU_PIPE_HANDLE pipe, const void* buffer, size_t len) {
+ return HostGoldfishPipeDevice::get()->write(pipe, buffer, len);
+}
+
+bool qemu_pipe_try_again() {
+ int err = HostGoldfishPipeDevice::get()->getErrno();
+ return err == EINTR || err == EAGAIN;
+}
+
+bool qemu_pipe_valid(QEMU_PIPE_HANDLE pipe) {
+ return pipe != NULL;
+}
+
+void qemu_pipe_print_error(QEMU_PIPE_HANDLE pipe) {
+ int err = HostGoldfishPipeDevice::get()->getErrno();
+ ALOGE("pipe error: pipe %p err %d", pipe, err);
+}
diff --git a/system/GLESv1/CMakeLists.txt b/system/GLESv1/CMakeLists.txt
new file mode 100644
index 0000000..9642bb2
--- /dev/null
+++ b/system/GLESv1/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv1/Android.mk" "e095cb082e3791719749cfc80b90560afd7348eb0d7895449d2509aa129bea75")
+set(GLESv1_CM_emulation_src gl.cpp)
+android_add_shared_library(GLESv1_CM_emulation)
+target_include_directories(GLESv1_CM_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(GLESv1_CM_emulation PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"GLES_emulation\"")
+target_compile_options(GLESv1_CM_emulation PRIVATE "-fvisibility=default")
+target_link_libraries(GLESv1_CM_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/GLESv1/gl.cpp b/system/GLESv1/gl.cpp
index 6e07004..56e1630 100644
--- a/system/GLESv1/gl.cpp
+++ b/system/GLESv1/gl.cpp
@@ -20,7 +20,6 @@
#include "GLES/gl.h"
#include "GLES/glext.h"
#include "ErrorLog.h"
-#include "gralloc_cb.h"
#include "ThreadInfo.h"
#include "EGLImage.h"
@@ -46,6 +45,11 @@
if (!rcEnc) { \
ALOGE("egl: Failed to get renderControl encoder context\n"); \
return ret; \
+ } \
+ Gralloc *grallocHelper = hostCon->grallocHelper(); \
+ if (!grallocHelper) { \
+ ALOGE("egl: Failed to get grallocHelper\n"); \
+ return ret; \
}
//GL extensions
@@ -74,7 +78,7 @@
ctx->override2DTextureTarget(target);
rcEnc->rcBindTexture(rcEnc,
- ((cb_handle_t *)(native_buffer->handle))->hostHandle);
+ grallocHelper->getHostHandle(native_buffer->handle));
ctx->restore2DTextureTarget();
}
else if (image->target == EGL_GL_TEXTURE_2D_KHR) {
@@ -107,7 +111,8 @@
}
DEFINE_AND_VALIDATE_HOST_CONNECTION();
- rcEnc->rcBindRenderbuffer(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle);
+ rcEnc->rcBindRenderbuffer(rcEnc,
+ grallocHelper->getHostHandle(native_buffer->handle));
} else {
//TODO
}
diff --git a/system/GLESv1_enc/Android.mk b/system/GLESv1_enc/Android.mk
index fd12395..48ee51f 100644
--- a/system/GLESv1_enc/Android.mk
+++ b/system/GLESv1_enc/Android.mk
@@ -12,7 +12,7 @@
gl_enc.cpp \
gl_entry.cpp
-$(call emugl-import,libOpenglCodecCommon)
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
$(call emugl-export,C_INCLUDES,$(intermediates))
diff --git a/system/GLESv1_enc/CMakeLists.txt b/system/GLESv1_enc/CMakeLists.txt
new file mode 100644
index 0000000..1b86cdb
--- /dev/null
+++ b/system/GLESv1_enc/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc/Android.mk" "953e6b7371d10eed63a4be555f8f1fb6f347338484a78102fa8f55dff96f5d3b")
+set(GLESv1_enc_src GLEncoder.cpp GLEncoderUtils.cpp gl_client_context.cpp gl_enc.cpp gl_entry.cpp)
+android_add_shared_library(GLESv1_enc)
+target_include_directories(GLESv1_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(GLESv1_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"emuglGLESv1_enc\"")
+target_compile_options(GLESv1_enc PRIVATE "-fvisibility=default")
+target_link_libraries(GLESv1_enc PRIVATE OpenglCodecCommon_host cutils utils log android-emu-shared)
\ No newline at end of file
diff --git a/system/GLESv1_enc/gl_enc.cpp b/system/GLESv1_enc/gl_enc.cpp
index 79df3d7..31c1269 100644
--- a/system/GLESv1_enc/gl_enc.cpp
+++ b/system/GLESv1_enc/gl_enc.cpp
@@ -8,6 +8,8 @@
#include "gl_enc.h"
+#include <vector>
+
#include <stdio.h>
namespace {
diff --git a/system/GLESv2/CMakeLists.txt b/system/GLESv2/CMakeLists.txt
new file mode 100644
index 0000000..7738bcd
--- /dev/null
+++ b/system/GLESv2/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv2/Android.mk" "d8f9dda69ec57ad8b7a65f02c3335b16a4724f612dec1d1a2cd793c28c0a10f9")
+set(GLESv2_emulation_src gl2.cpp)
+android_add_shared_library(GLESv2_emulation)
+target_include_directories(GLESv2_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(GLESv2_emulation PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"GLESv2_emulation\"")
+target_compile_options(GLESv2_emulation PRIVATE "-fvisibility=default")
+target_link_libraries(GLESv2_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/GLESv2/gl2.cpp b/system/GLESv2/gl2.cpp
index 0a2bf8e..a36bdd3 100644
--- a/system/GLESv2/gl2.cpp
+++ b/system/GLESv2/gl2.cpp
@@ -20,7 +20,6 @@
#include "GLES/gl.h"
#include "GLES/glext.h"
#include "ErrorLog.h"
-#include "gralloc_cb.h"
#include "ThreadInfo.h"
#include "EGLImage.h"
@@ -46,6 +45,11 @@
if (!rcEnc) { \
ALOGE("egl: Failed to get renderControl encoder context\n"); \
return ret; \
+ } \
+ Gralloc *grallocHelper = hostCon->grallocHelper(); \
+ if (!grallocHelper) { \
+ ALOGE("egl: Failed to get grallocHelper\n"); \
+ return ret; \
}
//GL extensions
@@ -76,7 +80,8 @@
ctx->override2DTextureTarget(target);
ctx->associateEGLImage(target, hostImage);
- rcEnc->rcBindTexture(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle);
+ rcEnc->rcBindTexture(rcEnc,
+ grallocHelper->getHostHandle(native_buffer->handle));
ctx->restore2DTextureTarget(target);
}
else if (image->target == EGL_GL_TEXTURE_2D_KHR) {
@@ -109,7 +114,8 @@
}
DEFINE_AND_VALIDATE_HOST_CONNECTION();
- rcEnc->rcBindRenderbuffer(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle);
+ rcEnc->rcBindRenderbuffer(rcEnc,
+ grallocHelper->getHostHandle(native_buffer->handle));
} else {
//TODO
}
diff --git a/system/GLESv2_enc/Android.mk b/system/GLESv2_enc/Android.mk
index f61c9f7..12bb013 100644
--- a/system/GLESv2_enc/Android.mk
+++ b/system/GLESv2_enc/Android.mk
@@ -15,7 +15,7 @@
LOCAL_CFLAGS += -DLOG_TAG=\"emuglGLESv2_enc\"
$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
-$(call emugl-import,libOpenglCodecCommon)
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
$(call emugl-end-module)
diff --git a/system/GLESv2_enc/CMakeLists.txt b/system/GLESv2_enc/CMakeLists.txt
new file mode 100644
index 0000000..87534fc
--- /dev/null
+++ b/system/GLESv2_enc/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc/Android.mk" "61772afe3e393d4ff6add7929ed232da8e614e44bf903018a91c774bc5b54a18")
+set(GLESv2_enc_src GL2EncoderUtils.cpp GL2Encoder.cpp GLESv2Validation.cpp gl2_client_context.cpp gl2_enc.cpp gl2_entry.cpp ../enc_common/IOStream_common.cpp)
+android_add_shared_library(GLESv2_enc)
+target_include_directories(GLESv2_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(GLESv2_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"emuglGLESv2_enc\"")
+target_compile_options(GLESv2_enc PRIVATE "-fvisibility=default")
+target_link_libraries(GLESv2_enc PRIVATE OpenglCodecCommon_host cutils utils log android-emu-shared)
\ No newline at end of file
diff --git a/system/GLESv2_enc/GL2Encoder.cpp b/system/GLESv2_enc/GL2Encoder.cpp
index 8b07e66..220f198 100755
--- a/system/GLESv2_enc/GL2Encoder.cpp
+++ b/system/GLESv2_enc/GL2Encoder.cpp
@@ -77,11 +77,24 @@
m_state = NULL;
m_error = GL_NO_ERROR;
m_num_compressedTextureFormats = 0;
+ m_max_combinedTextureImageUnits = 0;
+ m_max_vertexTextureImageUnits = 0;
+ m_max_textureImageUnits = 0;
m_max_cubeMapTextureSize = 0;
m_max_renderBufferSize = 0;
m_max_textureSize = 0;
m_max_3d_textureSize = 0;
m_max_vertexAttribStride = 0;
+
+ m_max_transformFeedbackSeparateAttribs = 0;
+ m_max_uniformBufferBindings = 0;
+ m_max_colorAttachments = 0;
+ m_max_drawBuffers = 0;
+
+ m_max_atomicCounterBufferBindings = 0;
+ m_max_shaderStorageBufferBindings = 0;
+ m_max_vertexAttribBindings = 0;
+
m_compressedTextureFormats = NULL;
m_ssbo_offset_align = 0;
@@ -536,7 +549,7 @@
SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
SET_ERROR_IF(size<0, GL_INVALID_VALUE);
- ctx->m_shared->updateBufferData(bufferId, size, (void*)data);
+ ctx->m_shared->updateBufferData(bufferId, size, data);
ctx->m_shared->setBufferUsage(bufferId, usage);
ctx->m_glBufferData_enc(self, target, size, data, usage);
}
@@ -549,7 +562,7 @@
SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
SET_ERROR_IF(ctx->isBufferTargetMapped(target), GL_INVALID_OPERATION);
- GLenum res = ctx->m_shared->subUpdateBufferData(bufferId, offset, size, (void*)data);
+ GLenum res = ctx->m_shared->subUpdateBufferData(bufferId, offset, size, data);
SET_ERROR_IF(res, res);
ctx->m_glBufferSubData_enc(self, target, offset, size, data);
@@ -632,7 +645,6 @@
void GL2Encoder::s_glGetIntegerv(void *self, GLenum param, GLint *ptr)
{
GL2Encoder *ctx = (GL2Encoder *) self;
- assert(ctx->m_state != NULL);
GLClientState* state = ctx->m_state;
switch (param) {
@@ -663,23 +675,43 @@
}
case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
- case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
- case GL_MAX_TEXTURE_IMAGE_UNITS:
- ctx->safe_glGetIntegerv(param, ptr);
- *ptr = MIN(*ptr, GLClientState::MAX_TEXTURE_UNITS);
+ if (ctx->m_max_combinedTextureImageUnits != 0) {
+ *ptr = ctx->m_max_combinedTextureImageUnits;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_combinedTextureImageUnits = *ptr;
+ }
break;
-
+ case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+ if (ctx->m_max_vertexTextureImageUnits != 0) {
+ *ptr = ctx->m_max_vertexTextureImageUnits;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_vertexTextureImageUnits = *ptr;
+ }
+ break;
+ case GL_MAX_TEXTURE_IMAGE_UNITS:
+ if (ctx->m_max_textureImageUnits != 0) {
+ *ptr = ctx->m_max_textureImageUnits;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_textureImageUnits = *ptr;
+ }
+ break;
case GL_TEXTURE_BINDING_2D:
+ SET_ERROR_IF(!state, GL_INVALID_OPERATION);
*ptr = state->getBoundTexture(GL_TEXTURE_2D);
break;
case GL_TEXTURE_BINDING_EXTERNAL_OES:
+ SET_ERROR_IF(!state, GL_INVALID_OPERATION);
*ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES);
break;
case GL_MAX_VERTEX_ATTRIBS:
- if (!ctx->m_state->getClientStateParameter<GLint>(param, ptr)) {
+ SET_ERROR_IF(!state, GL_INVALID_OPERATION);
+ if (!state->getClientStateParameter<GLint>(param, ptr)) {
ctx->safe_glGetIntegerv(param, ptr);
- ctx->m_state->setMaxVertexAttribs(*ptr);
+ state->setMaxVertexAttribs(*ptr);
}
break;
case GL_MAX_VERTEX_ATTRIB_STRIDE:
@@ -749,27 +781,80 @@
// Checks for version-incompatible enums.
// Not allowed in vanilla ES 2.0.
case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
+ SET_ERROR_IF(ctx->majorVersion() < 3, GL_INVALID_ENUM);
+ if (ctx->m_max_transformFeedbackSeparateAttribs != 0) {
+ *ptr = ctx->m_max_transformFeedbackSeparateAttribs;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_transformFeedbackSeparateAttribs = *ptr;
+ }
+ break;
case GL_MAX_UNIFORM_BUFFER_BINDINGS:
SET_ERROR_IF(ctx->majorVersion() < 3, GL_INVALID_ENUM);
- ctx->safe_glGetIntegerv(param, ptr);
+ if (ctx->m_max_uniformBufferBindings != 0) {
+ *ptr = ctx->m_max_uniformBufferBindings;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_uniformBufferBindings = *ptr;
+ }
break;
case GL_MAX_COLOR_ATTACHMENTS:
+ SET_ERROR_IF(ctx->majorVersion() < 3 &&
+ !ctx->hasExtension("GL_EXT_draw_buffers"), GL_INVALID_ENUM);
+ if (ctx->m_max_colorAttachments != 0) {
+ *ptr = ctx->m_max_colorAttachments;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_colorAttachments = *ptr;
+ }
+ break;
case GL_MAX_DRAW_BUFFERS:
SET_ERROR_IF(ctx->majorVersion() < 3 &&
!ctx->hasExtension("GL_EXT_draw_buffers"), GL_INVALID_ENUM);
- ctx->safe_glGetIntegerv(param, ptr);
+ if (ctx->m_max_drawBuffers != 0) {
+ *ptr = ctx->m_max_drawBuffers;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_drawBuffers = *ptr;
+ }
break;
// Not allowed in ES 3.0.
case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
+ SET_ERROR_IF(ctx->majorVersion() < 3 ||
+ (ctx->majorVersion() == 3 &&
+ ctx->minorVersion() == 0), GL_INVALID_ENUM);
+ if (ctx->m_max_atomicCounterBufferBindings != 0) {
+ *ptr = ctx->m_max_atomicCounterBufferBindings;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_atomicCounterBufferBindings = *ptr;
+ }
+ break;
case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
+ SET_ERROR_IF(ctx->majorVersion() < 3 ||
+ (ctx->majorVersion() == 3 &&
+ ctx->minorVersion() == 0), GL_INVALID_ENUM);
+ if (ctx->m_max_shaderStorageBufferBindings != 0) {
+ *ptr = ctx->m_max_shaderStorageBufferBindings;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_shaderStorageBufferBindings = *ptr;
+ }
+ break;
case GL_MAX_VERTEX_ATTRIB_BINDINGS:
SET_ERROR_IF(ctx->majorVersion() < 3 ||
(ctx->majorVersion() == 3 &&
ctx->minorVersion() == 0), GL_INVALID_ENUM);
- ctx->safe_glGetIntegerv(param, ptr);
+ if (ctx->m_max_vertexAttribBindings != 0) {
+ *ptr = ctx->m_max_vertexAttribBindings;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_max_vertexAttribBindings = *ptr;
+ }
break;
default:
- if (!ctx->m_state->getClientStateParameter<GLint>(param, ptr)) {
+ SET_ERROR_IF(!state, GL_INVALID_OPERATION);
+ if (!state->getClientStateParameter<GLint>(param, ptr)) {
ctx->safe_glGetIntegerv(param, ptr);
}
break;
@@ -780,7 +865,6 @@
void GL2Encoder::s_glGetFloatv(void *self, GLenum param, GLfloat *ptr)
{
GL2Encoder *ctx = (GL2Encoder *)self;
- assert(ctx->m_state != NULL);
GLClientState* state = ctx->m_state;
switch (param) {
@@ -805,19 +889,36 @@
case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
case GL_MAX_TEXTURE_IMAGE_UNITS:
- ctx->safe_glGetFloatv(param, ptr);
- *ptr = MIN(*ptr, (GLfloat)GLClientState::MAX_TEXTURE_UNITS);
- break;
-
+ case GL_MAX_VERTEX_ATTRIBS:
+ case GL_MAX_VERTEX_ATTRIB_STRIDE:
+ case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+ case GL_MAX_RENDERBUFFER_SIZE:
+ case GL_MAX_TEXTURE_SIZE:
+ case GL_MAX_3D_TEXTURE_SIZE:
+ case GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
+ case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
+ case GL_MAX_SAMPLES:
+ case GL_MAX_COLOR_TEXTURE_SAMPLES:
+ case GL_MAX_INTEGER_SAMPLES:
+ case GL_MAX_DEPTH_TEXTURE_SAMPLES:
+ case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
+ case GL_MAX_UNIFORM_BUFFER_BINDINGS:
+ case GL_MAX_COLOR_ATTACHMENTS:
+ case GL_MAX_DRAW_BUFFERS:
+ case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
+ case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
+ case GL_MAX_VERTEX_ATTRIB_BINDINGS:
case GL_TEXTURE_BINDING_2D:
- *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_2D);
+ case GL_TEXTURE_BINDING_EXTERNAL_OES: {
+ GLint res;
+ s_glGetIntegerv(ctx, param, &res);
+ *ptr = (GLfloat)res;
break;
- case GL_TEXTURE_BINDING_EXTERNAL_OES:
- *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES);
- break;
+ }
default:
- if (!ctx->m_state->getClientStateParameter<GLfloat>(param, ptr)) {
+ SET_ERROR_IF(!state, GL_INVALID_OPERATION);
+ if (!state->getClientStateParameter<GLfloat>(param, ptr)) {
ctx->safe_glGetFloatv(param, ptr);
}
break;
@@ -828,7 +929,6 @@
void GL2Encoder::s_glGetBooleanv(void *self, GLenum param, GLboolean *ptr)
{
GL2Encoder *ctx = (GL2Encoder *)self;
- assert(ctx->m_state != NULL);
GLClientState* state = ctx->m_state;
switch (param) {
@@ -850,16 +950,39 @@
break;
}
+ case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+ case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+ case GL_MAX_TEXTURE_IMAGE_UNITS:
+ case GL_MAX_VERTEX_ATTRIBS:
+ case GL_MAX_VERTEX_ATTRIB_STRIDE:
+ case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+ case GL_MAX_RENDERBUFFER_SIZE:
+ case GL_MAX_TEXTURE_SIZE:
+ case GL_MAX_3D_TEXTURE_SIZE:
+ case GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT:
+ case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
+ case GL_MAX_SAMPLES:
+ case GL_MAX_COLOR_TEXTURE_SAMPLES:
+ case GL_MAX_INTEGER_SAMPLES:
+ case GL_MAX_DEPTH_TEXTURE_SAMPLES:
+ case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
+ case GL_MAX_UNIFORM_BUFFER_BINDINGS:
+ case GL_MAX_COLOR_ATTACHMENTS:
+ case GL_MAX_DRAW_BUFFERS:
+ case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
+ case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
+ case GL_MAX_VERTEX_ATTRIB_BINDINGS:
case GL_TEXTURE_BINDING_2D:
- *ptr = state->getBoundTexture(GL_TEXTURE_2D) != 0 ? GL_TRUE : GL_FALSE;
+ case GL_TEXTURE_BINDING_EXTERNAL_OES: {
+ GLint res;
+ s_glGetIntegerv(ctx, param, &res);
+ *ptr = res == 0 ? GL_FALSE : GL_TRUE;
break;
- case GL_TEXTURE_BINDING_EXTERNAL_OES:
- *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES) != 0
- ? GL_TRUE : GL_FALSE;
- break;
+ }
default:
- if (!ctx->m_state->getClientStateParameter<GLboolean>(param, ptr)) {
+ SET_ERROR_IF(!state, GL_INVALID_OPERATION);
+ if (!state->getClientStateParameter<GLboolean>(param, ptr)) {
ctx->safe_glGetBooleanv(param, ptr);
}
*ptr = (*ptr != 0) ? GL_TRUE : GL_FALSE;
@@ -1133,7 +1256,7 @@
if (buf) {
ALOGE("Out of bounds vertex attribute info: "
"clientArray? %d attribute %d vbo %u allocedBufferSize %u bufferDataSpecified? %d wantedStart %u wantedEnd %u",
- hasClientArrays, i, bufferObject, buf->m_size, buf != NULL, firstIndex, firstIndex + bufLen);
+ hasClientArrays, i, bufferObject, (unsigned int)buf->m_size, buf != NULL, firstIndex, firstIndex + bufLen);
}
m_glDisableVertexAttribArray_enc(this, i);
}
@@ -1255,6 +1378,8 @@
&maxIndex);
}
+ if (count == 0) return;
+
bool adjustIndices = true;
if (ctx->m_state->currentIndexVbo() != 0) {
if (!has_client_vertex_arrays) {
@@ -1414,8 +1539,10 @@
do {
c++;
} while (isalnum(*c) || *c == '_');
+
+ size_t len = (size_t)(c - name_start);
data->samplerExternalNames.push_back(
- android::String8(name_start, c - name_start));
+ std::string(name_start, len));
// We only need to perform a string replacement for the original
// occurrence of samplerExternalOES if a #define was used.
@@ -2691,6 +2818,20 @@
return ctx->glUnmapBuffer(ctx, target);
}
+void* GL2Encoder::s_glMapBufferRangeAEMUImpl(GL2Encoder* ctx, GLenum target,
+ GLintptr offset, GLsizeiptr length,
+ GLbitfield access, BufferData* buf) {
+ char* bits = (char*)buf->m_fixedBuffer.ptr() + offset;
+
+ ctx->glMapBufferRangeAEMU(
+ ctx, target,
+ offset, length,
+ access,
+ bits);
+
+ return bits;
+}
+
void* GL2Encoder::s_glMapBufferRange(void* self, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
GL2Encoder* ctx = (GL2Encoder*)self;
GLClientState* state = ctx->m_state;
@@ -2729,14 +2870,37 @@
buf->m_mappedOffset = offset;
buf->m_mappedLength = length;
- char* todo = (char*)buf->m_fixedBuffer.ptr() + offset;
- ctx->glMapBufferRangeAEMU(
- ctx, target,
- offset, length,
- access,
- todo);
+ if (ctx->hasExtension("ANDROID_EMU_dma_v2")) {
+ if (buf->dma_buffer.get().size < length) {
+ goldfish_dma_context region;
- return todo;
+ const int PAGE_BITS = 12;
+ GLsizeiptr aligned_length = (length + (1 << PAGE_BITS) - 1) & ~((1 << PAGE_BITS) - 1);
+
+ if (goldfish_dma_create_region(aligned_length, ®ion)) {
+ buf->dma_buffer.reset(NULL);
+ return s_glMapBufferRangeAEMUImpl(ctx, target, offset, length, access, buf);
+ }
+
+ if (!goldfish_dma_map(®ion)) {
+ buf->dma_buffer.reset(NULL);
+ return s_glMapBufferRangeAEMUImpl(ctx, target, offset, length, access, buf);
+ }
+
+ buf->m_guest_paddr = goldfish_dma_guest_paddr(®ion);
+ buf->dma_buffer.reset(®ion);
+ }
+
+ ctx->glMapBufferRangeDMA(
+ ctx, target,
+ offset, length,
+ access,
+ buf->m_guest_paddr);
+
+ return reinterpret_cast<void*>(buf->dma_buffer.get().mapped_addr);
+ } else {
+ return s_glMapBufferRangeAEMUImpl(ctx, target, offset, length, access, buf);
+ }
}
GLboolean GL2Encoder::s_glUnmapBuffer(void* self, GLenum target) {
@@ -2764,13 +2928,27 @@
GLboolean host_res = GL_TRUE;
- ctx->glUnmapBufferAEMU(
- ctx, target,
- buf->m_mappedOffset,
- buf->m_mappedLength,
- buf->m_mappedAccess,
- (void*)((char*)buf->m_fixedBuffer.ptr() + buf->m_mappedOffset),
- &host_res);
+ if (buf->dma_buffer.get().mapped_addr) {
+ memcpy(static_cast<char*>(buf->m_fixedBuffer.ptr()) + buf->m_mappedOffset,
+ reinterpret_cast<void*>(buf->dma_buffer.get().mapped_addr),
+ buf->m_mappedLength);
+
+ ctx->glUnmapBufferDMA(
+ ctx, target,
+ buf->m_mappedOffset,
+ buf->m_mappedLength,
+ buf->m_mappedAccess,
+ goldfish_dma_guest_paddr(&buf->dma_buffer.get()),
+ &host_res);
+ } else {
+ ctx->glUnmapBufferAEMU(
+ ctx, target,
+ buf->m_mappedOffset,
+ buf->m_mappedLength,
+ buf->m_mappedAccess,
+ (void*)((char*)buf->m_fixedBuffer.ptr() + buf->m_mappedOffset),
+ &host_res);
+ }
buf->m_mapped = false;
buf->m_mappedAccess = 0;
@@ -3862,6 +4040,8 @@
&maxIndex);
}
+ if (count == 0) return;
+
bool adjustIndices = true;
if (ctx->m_state->currentIndexVbo() != 0) {
if (!has_client_vertex_arrays) {
@@ -3953,6 +4133,8 @@
&maxIndex);
}
+ if (count == 0) return;
+
bool adjustIndices = true;
if (ctx->m_state->currentIndexVbo() != 0) {
if (!has_client_vertex_arrays) {
@@ -4021,9 +4203,9 @@
retval);
RET_AND_SET_ERROR_IF(
- name == GL_VENDOR ||
- name == GL_RENDERER ||
- name == GL_VERSION ||
+ (name == GL_VENDOR ||
+ name == GL_RENDERER ||
+ name == GL_VERSION) &&
index != 0,
GL_INVALID_VALUE,
retval);
@@ -4522,9 +4704,8 @@
// Phase 1: create a ShaderData and initialize with replaceSamplerExternalWith2D()
uint32_t spDataId = ctx->m_shared->addNewShaderProgramData();
ShaderProgramData* spData = ctx->m_shared->getShaderProgramDataById(spDataId);
- ShaderData* sData = spData->shaderData;
- if (!replaceSamplerExternalWith2D(str, sData)) {
+ if (!replaceSamplerExternalWith2D(str, &spData->shaderData)) {
delete [] str;
ctx->setError(GL_OUT_OF_MEMORY);
ctx->m_shared->deleteShaderProgramDataById(spDataId);
diff --git a/system/GLESv2_enc/GL2Encoder.h b/system/GLESv2_enc/GL2Encoder.h
index 3018622..5b51f7b 100644
--- a/system/GLESv2_enc/GL2Encoder.h
+++ b/system/GLESv2_enc/GL2Encoder.h
@@ -108,12 +108,24 @@
GLint m_num_compressedTextureFormats;
GLint *getCompressedTextureFormats();
+ GLint m_max_combinedTextureImageUnits;
+ GLint m_max_vertexTextureImageUnits;
+ GLint m_max_textureImageUnits;
GLint m_max_cubeMapTextureSize;
GLint m_max_renderBufferSize;
GLint m_max_textureSize;
GLint m_max_3d_textureSize;
GLint m_max_vertexAttribStride;
+ GLint m_max_transformFeedbackSeparateAttribs;
+ GLint m_max_uniformBufferBindings;
+ GLint m_max_colorAttachments;
+ GLint m_max_drawBuffers;
+
+ GLint m_max_atomicCounterBufferBindings;
+ GLint m_max_shaderStorageBufferBindings;
+ GLint m_max_vertexAttribBindings;
+
GLuint m_ssbo_offset_align;
GLuint m_ubo_offset_align;
@@ -402,6 +414,9 @@
static void* s_glMapBufferOES(void* self, GLenum target, GLenum access);
static GLboolean s_glUnmapBufferOES(void* self, GLenum target);
static void* s_glMapBufferRange(void* self, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+ static void* s_glMapBufferRangeAEMUImpl(GL2Encoder* ctx, GLenum target,
+ GLintptr offset, GLsizeiptr length,
+ GLbitfield access, BufferData* buf);
static GLboolean s_glUnmapBuffer(void* self, GLenum target);
static void s_glFlushMappedBufferRange(void* self, GLenum target, GLintptr offset, GLsizeiptr length);
diff --git a/system/GLESv2_enc/gl2_client_context.cpp b/system/GLESv2_enc/gl2_client_context.cpp
index 9eb4ac4..7da3e33 100644
--- a/system/GLESv2_enc/gl2_client_context.cpp
+++ b/system/GLESv2_enc/gl2_client_context.cpp
@@ -421,6 +421,8 @@
glGetFramebufferParameteriv = (glGetFramebufferParameteriv_client_proc_t) getProc("glGetFramebufferParameteriv", userData);
glGetTexLevelParameterfv = (glGetTexLevelParameterfv_client_proc_t) getProc("glGetTexLevelParameterfv", userData);
glGetTexLevelParameteriv = (glGetTexLevelParameteriv_client_proc_t) getProc("glGetTexLevelParameteriv", userData);
+ glMapBufferRangeDMA = (glMapBufferRangeDMA_client_proc_t) getProc("glMapBufferRangeDMA", userData);
+ glUnmapBufferDMA = (glUnmapBufferDMA_client_proc_t) getProc("glUnmapBufferDMA", userData);
return 0;
}
diff --git a/system/GLESv2_enc/gl2_client_context.h b/system/GLESv2_enc/gl2_client_context.h
index 6616e53..e2400a9 100644
--- a/system/GLESv2_enc/gl2_client_context.h
+++ b/system/GLESv2_enc/gl2_client_context.h
@@ -421,6 +421,8 @@
glGetFramebufferParameteriv_client_proc_t glGetFramebufferParameteriv;
glGetTexLevelParameterfv_client_proc_t glGetTexLevelParameterfv;
glGetTexLevelParameteriv_client_proc_t glGetTexLevelParameteriv;
+ glMapBufferRangeDMA_client_proc_t glMapBufferRangeDMA;
+ glUnmapBufferDMA_client_proc_t glUnmapBufferDMA;
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 8c88678..8829c58 100644
--- a/system/GLESv2_enc/gl2_client_proc.h
+++ b/system/GLESv2_enc/gl2_client_proc.h
@@ -420,6 +420,8 @@
typedef void (gl2_APIENTRY *glGetFramebufferParameteriv_client_proc_t) (void * ctx, GLenum, GLenum, GLint*);
typedef void (gl2_APIENTRY *glGetTexLevelParameterfv_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLfloat*);
typedef void (gl2_APIENTRY *glGetTexLevelParameteriv_client_proc_t) (void * ctx, GLenum, GLint, GLenum, GLint*);
+typedef void (gl2_APIENTRY *glMapBufferRangeDMA_client_proc_t) (void * ctx, GLenum, GLintptr, GLsizeiptr, GLbitfield, uint64_t);
+typedef void (gl2_APIENTRY *glUnmapBufferDMA_client_proc_t) (void * ctx, GLenum, GLintptr, GLsizeiptr, GLbitfield, uint64_t, GLboolean*);
#endif
diff --git a/system/GLESv2_enc/gl2_enc.cpp b/system/GLESv2_enc/gl2_enc.cpp
index f42e7ba..d5ae4b5 100644
--- a/system/GLESv2_enc/gl2_enc.cpp
+++ b/system/GLESv2_enc/gl2_enc.cpp
@@ -8,6 +8,8 @@
#include "gl2_enc.h"
+#include <vector>
+
#include <stdio.h>
namespace {
@@ -3028,8 +3030,7 @@
if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
- // TODO: make this part of autogenerated pipe code.
- // b/79208762
+ // TODO: emugen produces bad code here, see b/79208762
stream->readbackPixels(self, width, height, format, type, pixels);
if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
@@ -11043,6 +11044,78 @@
}
}
+void glMapBufferRangeDMA_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr)
+{
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glMapBufferRangeDMA;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &target, 4); ptr += 4;
+ memcpy(ptr, &offset, 4); ptr += 4;
+ memcpy(ptr, &length, 4); ptr += 4;
+ memcpy(ptr, &access, 4); ptr += 4;
+ memcpy(ptr, &paddr, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glUnmapBufferDMA_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr, GLboolean* out_res)
+{
+
+ 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_out_res = (sizeof(GLboolean));
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 8 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glUnmapBufferDMA;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &target, 4); ptr += 4;
+ memcpy(ptr, &offset, 4); ptr += 4;
+ memcpy(ptr, &length, 4); ptr += 4;
+ memcpy(ptr, &access, 4); ptr += 4;
+ memcpy(ptr, &paddr, 8); ptr += 8;
+ *(unsigned int *)(ptr) = __size_out_res; ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(out_res, __size_out_res);
+ if (useChecksum) checksumCalculator->addBuffer(out_res, __size_out_res);
+ 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("glUnmapBufferDMA: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+}
+
} // namespace
gl2_encoder_context_t::gl2_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
@@ -11461,5 +11534,7 @@
this->glGetFramebufferParameteriv = &glGetFramebufferParameteriv_enc;
this->glGetTexLevelParameterfv = &glGetTexLevelParameterfv_enc;
this->glGetTexLevelParameteriv = &glGetTexLevelParameteriv_enc;
+ this->glMapBufferRangeDMA = &glMapBufferRangeDMA_enc;
+ this->glUnmapBufferDMA = &glUnmapBufferDMA_enc;
}
diff --git a/system/GLESv2_enc/gl2_entry.cpp b/system/GLESv2_enc/gl2_entry.cpp
index 5713921..f60eb44 100644
--- a/system/GLESv2_enc/gl2_entry.cpp
+++ b/system/GLESv2_enc/gl2_entry.cpp
@@ -416,6 +416,8 @@
void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint* params);
void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat* params);
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params);
+ void glMapBufferRangeDMA(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr);
+ void glUnmapBufferDMA(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr, GLboolean* out_res);
};
#ifndef GET_CONTEXT
@@ -2927,3 +2929,15 @@
ctx->glGetTexLevelParameteriv(ctx, target, level, pname, params);
}
+void glMapBufferRangeDMA(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr)
+{
+ GET_CONTEXT;
+ ctx->glMapBufferRangeDMA(ctx, target, offset, length, access, paddr);
+}
+
+void glUnmapBufferDMA(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, uint64_t paddr, GLboolean* out_res)
+{
+ GET_CONTEXT;
+ ctx->glUnmapBufferDMA(ctx, target, offset, length, access, paddr, out_res);
+}
+
diff --git a/system/GLESv2_enc/gl2_opcodes.h b/system/GLESv2_enc/gl2_opcodes.h
index 497ebfb..2affe0e 100644
--- a/system/GLESv2_enc/gl2_opcodes.h
+++ b/system/GLESv2_enc/gl2_opcodes.h
@@ -414,7 +414,9 @@
#define OP_glGetFramebufferParameteriv 2456
#define OP_glGetTexLevelParameterfv 2457
#define OP_glGetTexLevelParameteriv 2458
-#define OP_last 2459
+#define OP_glMapBufferRangeDMA 2459
+#define OP_glUnmapBufferDMA 2460
+#define OP_last 2461
#endif
diff --git a/system/OpenglSystemCommon/Android.mk b/system/OpenglSystemCommon/Android.mk
index 9305119..e25e97d 100644
--- a/system/OpenglSystemCommon/Android.mk
+++ b/system/OpenglSystemCommon/Android.mk
@@ -3,13 +3,40 @@
$(call emugl-begin-shared-library,libOpenglSystemCommon)
$(call emugl-import,libGLESv1_enc libGLESv2_enc lib_renderControl_enc)
+ifeq (true,$(BUILD_EMULATOR_VULKAN))
+$(call emugl-import,libvulkan_enc)
+endif
+
LOCAL_SRC_FILES := \
- goldfish_dma.cpp \
FormatConversions.cpp \
HostConnection.cpp \
- ProcessPipe.cpp \
QemuPipeStream.cpp \
- ThreadInfo.cpp
+ ProcessPipe.cpp \
+
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+LOCAL_SRC_FILES += \
+ ThreadInfo_host.cpp \
+
+else
+
+ifeq (true,$(BUILD_EMULATOR_VULKAN))
+
+LOCAL_HEADER_LIBRARIES += vulkan_headers
+
+endif
+
+LOCAL_SRC_FILES += \
+ ThreadInfo.cpp \
+
+endif
+
+ifneq ($(filter virgl, $(BOARD_GPU_DRIVERS)),)
+LOCAL_CFLAGS += -DVIRTIO_GPU
+LOCAL_SRC_FILES += VirtioGpuStream.cpp
+LOCAL_C_INCLUDES += external/libdrm external/minigbm/cros_gralloc
+LOCAL_SHARED_LIBRARIES += libdrm
+endif
ifdef IS_AT_LEAST_OPD1
LOCAL_HEADER_LIBRARIES += libnativebase_headers
@@ -24,4 +51,8 @@
$(call emugl-export,C_INCLUDES,$(LOCAL_PATH) bionic/libc/private)
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+$(call emugl-export,SHARED_LIBRARIES,android-emu-shared)
+endif
+
$(call emugl-end-module)
diff --git a/system/OpenglSystemCommon/CMakeLists.txt b/system/OpenglSystemCommon/CMakeLists.txt
new file mode 100644
index 0000000..28e4075
--- /dev/null
+++ b/system/OpenglSystemCommon/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/Android.mk" "5ee7d71d6652a9dae3d1de93b9ff1ac36a26a40193aa8d2604965c766d2ed8ab")
+set(OpenglSystemCommon_src FormatConversions.cpp HostConnection.cpp QemuPipeStream.cpp ProcessPipe.cpp ThreadInfo_host.cpp)
+android_add_shared_library(OpenglSystemCommon)
+target_include_directories(OpenglSystemCommon PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(OpenglSystemCommon PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN")
+target_compile_options(OpenglSystemCommon PRIVATE "-fvisibility=default")
+target_link_libraries(OpenglSystemCommon PRIVATE android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/OpenglSystemCommon/EGLImage.h b/system/OpenglSystemCommon/EGLImage.h
index 6cb7431..a83e1ad 100644
--- a/system/OpenglSystemCommon/EGLImage.h
+++ b/system/OpenglSystemCommon/EGLImage.h
@@ -20,6 +20,9 @@
#include <EGL/eglext.h>
#include <GLES/gl.h>
+#include <hardware/hardware.h>
+#include <hardware/gralloc.h>
+
#if PLATFORM_SDK_VERSION >= 16
#if EMULATOR_OPENGL_POST_O >= 1
#include <nativebase/nativebase.h>
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index 34ddef4..c14e12d 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -17,23 +17,73 @@
#include "GLEncoder.h"
#include "GL2Encoder.h"
+
+#ifdef GOLDFISH_VULKAN
+#include "VkEncoder.h"
+#else
+namespace goldfish_vk {
+struct VkEncoder {
+ VkEncoder(IOStream*) { }
+ int placeholder;
+};
+} // namespace goldfish_vk
+#endif
+
+using goldfish_vk::VkEncoder;
+
#include "ProcessPipe.h"
#include "QemuPipeStream.h"
#include "TcpStream.h"
#include "ThreadInfo.h"
+#include "gralloc_cb.h"
+
+#ifdef VIRTIO_GPU
+#include "VirtioGpuStream.h"
+#endif
+
#include <cutils/log.h>
#define STREAM_BUFFER_SIZE (4*1024*1024)
#define STREAM_PORT_NUM 22468
-/* Set to 1 to use a QEMU pipe, or 0 for a TCP connection */
-#define USE_QEMU_PIPE 1
+enum HostConnectionType {
+ HOST_CONNECTION_TCP = 0,
+ HOST_CONNECTION_QEMU_PIPE = 1,
+ HOST_CONNECTION_VIRTIO_GPU = 2,
+};
+
+class GoldfishGralloc : public Gralloc
+{
+public:
+ uint32_t getHostHandle(native_handle_t const* handle)
+ {
+ return ((cb_handle_t *)handle)->hostHandle;
+ }
+
+ int getFormat(native_handle_t const* handle)
+ {
+ return ((cb_handle_t *)handle)->format;
+ }
+};
+
+class GoldfishProcessPipe : public ProcessPipe
+{
+public:
+ bool processPipeInit(renderControl_encoder_context_t *rcEnc)
+ {
+ return ::processPipeInit(rcEnc);
+ }
+};
+
+static GoldfishGralloc m_goldfishGralloc;
+static GoldfishProcessPipe m_goldfishProcessPipe;
HostConnection::HostConnection() :
m_stream(NULL),
m_glEnc(NULL),
m_gl2Enc(NULL),
+ m_vkEnc(NULL),
m_rcEnc(NULL),
m_checksumHelper(),
m_glExtensions(),
@@ -57,7 +107,7 @@
HostConnection *HostConnection::getWithThreadInfo(EGLThreadInfo* tinfo) {
/* TODO: Make this configurable with a system property */
- const int useQemuPipe = USE_QEMU_PIPE;
+ const enum HostConnectionType connType = HOST_CONNECTION_VIRTIO_GPU;
// Get thread info
if (!tinfo) {
@@ -70,38 +120,65 @@
return NULL;
}
- if (useQemuPipe) {
- QemuPipeStream *stream = new QemuPipeStream(STREAM_BUFFER_SIZE);
- if (!stream) {
- ALOGE("Failed to create QemuPipeStream for host connection!!!\n");
- delete con;
- return NULL;
+ switch (connType) {
+ default:
+ case HOST_CONNECTION_QEMU_PIPE: {
+ QemuPipeStream *stream = new QemuPipeStream(STREAM_BUFFER_SIZE);
+ if (!stream) {
+ ALOGE("Failed to create QemuPipeStream for host connection!!!\n");
+ delete con;
+ return NULL;
+ }
+ if (stream->connect() < 0) {
+ ALOGE("Failed to connect to host (QemuPipeStream)!!!\n");
+ delete stream;
+ delete con;
+ return NULL;
+ }
+ con->m_stream = stream;
+ con->m_grallocHelper = &m_goldfishGralloc;
+ con->m_processPipe = &m_goldfishProcessPipe;
+ break;
}
- if (stream->connect() < 0) {
- ALOGE("Failed to connect to host (QemuPipeStream)!!!\n");
- delete stream;
- delete con;
- return NULL;
- }
- con->m_stream = stream;
- con->m_pipeFd = stream->getSocket();
- }
- else /* !useQemuPipe */
- {
- TcpStream *stream = new TcpStream(STREAM_BUFFER_SIZE);
- if (!stream) {
- ALOGE("Failed to create TcpStream for host connection!!!\n");
- delete con;
- return NULL;
- }
+ case HOST_CONNECTION_TCP: {
+ TcpStream *stream = new TcpStream(STREAM_BUFFER_SIZE);
+ if (!stream) {
+ ALOGE("Failed to create TcpStream for host connection!!!\n");
+ delete con;
+ return NULL;
+ }
- if (stream->connect("10.0.2.2", STREAM_PORT_NUM) < 0) {
- ALOGE("Failed to connect to host (TcpStream)!!!\n");
- delete stream;
- delete con;
- return NULL;
+ if (stream->connect("10.0.2.2", STREAM_PORT_NUM) < 0) {
+ ALOGE("Failed to connect to host (TcpStream)!!!\n");
+ delete stream;
+ delete con;
+ return NULL;
+ }
+ con->m_stream = stream;
+ con->m_grallocHelper = &m_goldfishGralloc;
+ con->m_processPipe = &m_goldfishProcessPipe;
+ break;
}
- con->m_stream = stream;
+#ifdef VIRTIO_GPU
+ case HOST_CONNECTION_VIRTIO_GPU: {
+ VirtioGpuStream *stream = new VirtioGpuStream(STREAM_BUFFER_SIZE);
+ if (!stream) {
+ ALOGE("Failed to create VirtioGpu for host connection!!!\n");
+ delete con;
+ return NULL;
+ }
+ if (stream->connect() < 0) {
+ ALOGE("Failed to connect to host (VirtioGpu)!!!\n");
+ delete stream;
+ delete con;
+ return NULL;
+ }
+ con->m_stream = stream;
+ con->m_grallocHelper = stream->getGralloc();
+ con->m_processPipe = stream->getProcessPipe();
+ break;
+ }
+#endif
}
// send zero 'clientFlags' to the host.
@@ -110,7 +187,8 @@
*pClientFlags = 0;
con->m_stream->commitBuffer(sizeof(unsigned int));
- ALOGD("HostConnection::get() New Host Connection established %p, tid %d\n", con, gettid());
+ ALOGD("HostConnection::get() New Host Connection established %p, tid %d\n",
+ con, getCurrentThreadId());
tinfo->hostConn = con;
}
@@ -135,7 +213,8 @@
{
if (!m_glEnc) {
m_glEnc = new GLEncoder(m_stream, checksumHelper());
- DBG("HostConnection::glEncoder new encoder %p, tid %d", m_glEnc, gettid());
+ DBG("HostConnection::glEncoder new encoder %p, tid %d",
+ m_glEnc, getCurrentThreadId());
m_glEnc->setContextAccessor(s_getGLContext);
}
return m_glEnc;
@@ -145,13 +224,22 @@
{
if (!m_gl2Enc) {
m_gl2Enc = new GL2Encoder(m_stream, checksumHelper());
- DBG("HostConnection::gl2Encoder new encoder %p, tid %d", m_gl2Enc, gettid());
+ DBG("HostConnection::gl2Encoder new encoder %p, tid %d",
+ m_gl2Enc, getCurrentThreadId());
m_gl2Enc->setContextAccessor(s_getGL2Context);
m_gl2Enc->setNoHostError(m_noHostError);
}
return m_gl2Enc;
}
+VkEncoder *HostConnection::vkEncoder()
+{
+ if (!m_vkEnc) {
+ m_vkEnc = new VkEncoder(m_stream);
+ }
+ return m_vkEnc;
+}
+
ExtendedRCEncoderContext *HostConnection::rcEncoder()
{
if (!m_rcEnc) {
@@ -161,7 +249,10 @@
queryAndSetDmaImpl(m_rcEnc);
queryAndSetGLESMaxVersion(m_rcEnc);
queryAndSetNoErrorState(m_rcEnc);
- processPipeInit(m_rcEnc);
+ queryAndSetHostCompositionImpl(m_rcEnc);
+ if (m_processPipe) {
+ m_processPipe->processPipeInit(m_rcEnc);
+ }
}
return m_rcEnc;
}
@@ -212,6 +303,17 @@
return m_glExtensions;
}
+void HostConnection::queryAndSetHostCompositionImpl(ExtendedRCEncoderContext *rcEnc) {
+ const std::string& glExtensions = queryGLExtensions(rcEnc);
+ ALOGD("HostComposition ext %s", glExtensions.c_str());
+ if (glExtensions.find(kHostCompositionV1) != std::string::npos) {
+ rcEnc->setHostComposition(HOST_COMPOSITION_V1);
+ }
+ else {
+ rcEnc->setHostComposition(HOST_COMPOSITION_NONE);
+ }
+}
+
void HostConnection::setChecksumHelper(ExtendedRCEncoderContext *rcEnc) {
const std::string& glExtensions = queryGLExtensions(rcEnc);
// check the host supported version
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index 2b49857..ac2f330 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -21,6 +21,7 @@
#include "ChecksumCalculator.h"
#include "goldfish_dma.h"
+#include <cutils/native_handle.h>
#include <string>
class GLEncoder;
@@ -28,6 +29,10 @@
class GL2Encoder;
struct gl2_client_context_t;
+namespace goldfish_vk {
+class VkEncoder;
+}
+
// SyncImpl determines the presence of host/guest OpenGL fence sync
// capabilities. It corresponds exactly to EGL_ANDROID_native_fence_sync
// capability, but for the emulator, we need to make sure that
@@ -71,6 +76,12 @@
static const char kGLESMaxVersion_3_1[] = "ANDROID_EMU_gles_max_version_3_1";
static const char kGLESMaxVersion_3_2[] = "ANDROID_EMU_gles_max_version_3_2";
+enum HostComposition {
+ HOST_COMPOSITION_NONE = 0,
+ HOST_COMPOSITION_V1,
+};
+static const char kHostCompositionV1[] = "ANDROID_EMU_host_composition_v1";
+
// No querying errors from host extension
static const char kGLESNoHostError[] = "ANDROID_EMU_gles_no_host_error";
@@ -84,8 +95,12 @@
}
void setSyncImpl(SyncImpl syncImpl) { m_syncImpl = syncImpl; }
void setDmaImpl(DmaImpl dmaImpl) { m_dmaImpl = dmaImpl; }
+ void setHostComposition(HostComposition hostComposition) {
+ m_hostComposition = hostComposition; }
bool hasNativeSync() const { return m_syncImpl >= SYNC_IMPL_NATIVE_SYNC_V2; }
bool hasNativeSyncV3() const { return m_syncImpl >= SYNC_IMPL_NATIVE_SYNC_V3; }
+ bool hasHostCompositionV1() const {
+ return m_hostComposition == HOST_COMPOSITION_V1; }
DmaImpl getDmaVersion() const { return m_dmaImpl; }
void bindDmaContext(struct goldfish_dma_context* cxt) { m_dmaCxt = cxt; }
virtual uint64_t lockAndWriteDma(void* data, uint32_t size) {
@@ -98,7 +113,7 @@
goldfish_dma_lock(m_dmaCxt);
goldfish_dma_write(m_dmaCxt, data, size);
uint64_t paddr = goldfish_dma_guest_paddr(m_dmaCxt);
- ALOGV("%s: paddr=0x%llx", __FUNCTION__, paddr);
+ ALOGV("%s: paddr=0x%llx", __FUNCTION__, (unsigned long long)paddr);
return paddr;
}
void setGLESMaxVersion(GLESMaxVersion ver) { m_glesMaxVersion = ver; }
@@ -106,10 +121,26 @@
private:
SyncImpl m_syncImpl;
DmaImpl m_dmaImpl;
+ HostComposition m_hostComposition;
struct goldfish_dma_context* m_dmaCxt;
GLESMaxVersion m_glesMaxVersion;
};
+// Abstraction for gralloc handle conversion
+class Gralloc {
+public:
+ virtual uint32_t getHostHandle(native_handle_t const* handle) = 0;
+ virtual int getFormat(native_handle_t const* handle) = 0;
+ virtual ~Gralloc() {}
+};
+
+// Abstraction for process pipe helper
+class ProcessPipe {
+public:
+ virtual bool processPipeInit(renderControl_encoder_context_t *rcEnc) = 0;
+ virtual ~ProcessPipe() {}
+};
+
struct EGLThreadInfo;
class HostConnection
@@ -122,8 +153,10 @@
GLEncoder *glEncoder();
GL2Encoder *gl2Encoder();
+ goldfish_vk::VkEncoder *vkEncoder();
ExtendedRCEncoderContext *rcEncoder();
ChecksumCalculator *checksumHelper() { return &m_checksumHelper; }
+ Gralloc *grallocHelper() { return m_grallocHelper; }
void flush() {
if (m_stream) {
@@ -137,8 +170,6 @@
bool isGrallocOnly() const { return m_grallocOnly; }
- int getPipeFd() const { return m_pipeFd; }
-
private:
HostConnection();
static gl_client_context_t *s_getGLContext();
@@ -152,16 +183,19 @@
void queryAndSetDmaImpl(ExtendedRCEncoderContext *rcEnc);
void queryAndSetGLESMaxVersion(ExtendedRCEncoderContext *rcEnc);
void queryAndSetNoErrorState(ExtendedRCEncoderContext *rcEnc);
+ void queryAndSetHostCompositionImpl(ExtendedRCEncoderContext *rcEnc);
private:
IOStream *m_stream;
GLEncoder *m_glEnc;
GL2Encoder *m_gl2Enc;
+ goldfish_vk::VkEncoder *m_vkEnc;
ExtendedRCEncoderContext *m_rcEnc;
ChecksumCalculator m_checksumHelper;
+ Gralloc *m_grallocHelper;
+ ProcessPipe *m_processPipe;
std::string m_glExtensions;
bool m_grallocOnly;
- int m_pipeFd;
bool m_noHostError;
};
diff --git a/system/OpenglSystemCommon/ProcessPipe.cpp b/system/OpenglSystemCommon/ProcessPipe.cpp
index 127f273..08e9571 100644
--- a/system/OpenglSystemCommon/ProcessPipe.cpp
+++ b/system/OpenglSystemCommon/ProcessPipe.cpp
@@ -19,8 +19,9 @@
#include <cutils/log.h>
#include <pthread.h>
+#include <errno.h>
-static int sProcPipe = 0;
+static QEMU_PIPE_HANDLE sProcPipe = 0;
static pthread_once_t sProcPipeOnce = PTHREAD_ONCE_INIT;
// sProcUID is a unique ID per process assigned by the host.
// It is different from getpid().
@@ -35,7 +36,7 @@
// host.
static void processPipeInitOnce() {
sProcPipe = qemu_pipe_open("GLProcessPipe");
- if (sProcPipe < 0) {
+ if (!qemu_pipe_valid(sProcPipe)) {
sProcPipe = 0;
ALOGW("Process pipe failed");
return;
@@ -44,12 +45,13 @@
int32_t confirmInt = 100;
ssize_t stat = 0;
do {
- stat = ::write(sProcPipe, (const char*)&confirmInt,
+ stat =
+ qemu_pipe_write(sProcPipe, (const char*)&confirmInt,
sizeof(confirmInt));
} while (stat < 0 && errno == EINTR);
if (stat != sizeof(confirmInt)) { // failed
- close(sProcPipe);
+ qemu_pipe_close(sProcPipe);
sProcPipe = 0;
ALOGW("Process pipe failed");
return;
@@ -57,12 +59,13 @@
// Ask the host for per-process unique ID
do {
- stat = ::read(sProcPipe, (char*)&sProcUID,
- sizeof(sProcUID));
+ stat =
+ qemu_pipe_read(sProcPipe, (char*)&sProcUID,
+ sizeof(sProcUID));
} while (stat < 0 && errno == EINTR);
if (stat != sizeof(sProcUID)) {
- close(sProcPipe);
+ qemu_pipe_close(sProcPipe);
sProcPipe = 0;
sProcUID = 0;
ALOGW("Process pipe failed");
diff --git a/system/OpenglSystemCommon/QemuPipeStream.cpp b/system/OpenglSystemCommon/QemuPipeStream.cpp
index 58703bf..cfe0fbd 100644
--- a/system/OpenglSystemCommon/QemuPipeStream.cpp
+++ b/system/OpenglSystemCommon/QemuPipeStream.cpp
@@ -14,8 +14,8 @@
* limitations under the License.
*/
#include "QemuPipeStream.h"
-#include "qemu_pipe.h"
+#include <cutils/log.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
@@ -24,13 +24,13 @@
QemuPipeStream::QemuPipeStream(size_t bufSize) :
IOStream(bufSize),
- m_sock(-1),
+ m_sock((QEMU_PIPE_HANDLE)(-1)),
m_bufsize(bufSize),
m_buf(NULL)
{
}
-QemuPipeStream::QemuPipeStream(int sock, size_t bufSize) :
+QemuPipeStream::QemuPipeStream(QEMU_PIPE_HANDLE sock, size_t bufSize) :
IOStream(bufSize),
m_sock(sock),
m_bufsize(bufSize),
@@ -40,9 +40,9 @@
QemuPipeStream::~QemuPipeStream()
{
- if (m_sock >= 0) {
+ if (valid()) {
flush();
- ::close(m_sock);
+ qemu_pipe_close(m_sock);
}
if (m_buf != NULL) {
free(m_buf);
@@ -52,9 +52,10 @@
int QemuPipeStream::connect(void)
{
- m_sock = qemu_pipe_open("opengles");
+ m_sock = qemu_pipe_open("opengles");
if (!valid()) {
- ALOGE("%s: failed with fd %d errno %d", __FUNCTION__, m_sock, errno);
+ ALOGE("%s: failed to connect to opengles pipe", __FUNCTION__);
+ qemu_pipe_print_error(m_sock);
return -1;
}
return 0;
@@ -72,7 +73,7 @@
m_buf = p;
m_bufsize = allocSize;
} else {
- ERR("realloc (%d) failed\n", allocSize);
+ ERR("realloc (%zu) failed\n", allocSize);
free(m_buf);
m_buf = NULL;
m_bufsize = 0;
@@ -95,7 +96,7 @@
if (len>0) {
// If len is non-zero, buf must not be NULL. Otherwise the pipe would be
// in a corrupted state, which is lethal for the emulator.
- ERR("QemuPipeStream::writeFully failed, buf=NULL, len %d,"
+ ERR("QemuPipeStream::writeFully failed, buf=NULL, len %zu,"
" lethal error, exiting", len);
abort();
}
@@ -106,7 +107,7 @@
int retval = 0;
while (res > 0) {
- ssize_t stat = ::write(m_sock, (const char *)(buf) + (len - res), res);
+ ssize_t stat = qemu_pipe_write(m_sock, (const char *)(buf) + (len - res), res);
if (stat > 0) {
res -= stat;
continue;
@@ -116,7 +117,7 @@
retval = -1;
break;
}
- if (errno == EINTR) {
+ if (qemu_pipe_try_again()) {
continue;
}
retval = stat;
@@ -128,7 +129,7 @@
return retval;
}
-int QemuPipeStream::getSocket() const {
+QEMU_PIPE_HANDLE QemuPipeStream::getSocket() const {
return m_sock;
}
@@ -148,12 +149,12 @@
}
size_t res = len;
while (res > 0) {
- ssize_t stat = ::read(m_sock, (char *)(buf) + len - res, res);
+ ssize_t stat = qemu_pipe_read(m_sock, (char *)(buf) + len - res, res);
if (stat == 0) {
// client shutdown;
return NULL;
} else if (stat < 0) {
- if (errno == EINTR) {
+ if (qemu_pipe_try_again()) {
continue;
} else {
ERR("QemuPipeStream::readFully failed (buf %p, len %zu"
@@ -195,7 +196,7 @@
char* p = (char *)buf;
int ret = 0;
while(len > 0) {
- int res = ::read(m_sock, p, len);
+ int res = qemu_pipe_read(m_sock, p, len);
if (res > 0) {
p += res;
ret += res;
@@ -205,7 +206,7 @@
if (res == 0) { /* EOF */
break;
}
- if (errno == EINTR)
+ if (qemu_pipe_try_again())
continue;
/* A real error */
diff --git a/system/OpenglSystemCommon/QemuPipeStream.h b/system/OpenglSystemCommon/QemuPipeStream.h
index 15f74e6..0884d57 100644
--- a/system/OpenglSystemCommon/QemuPipeStream.h
+++ b/system/OpenglSystemCommon/QemuPipeStream.h
@@ -23,6 +23,8 @@
#include <stdlib.h>
#include "IOStream.h"
+#include "qemu_pipe.h"
+
class QemuPipeStream : public IOStream {
public:
typedef enum { ERR_INVALID_SOCKET = -1000 } QemuPipeStreamError;
@@ -36,17 +38,17 @@
virtual const unsigned char *readFully( void *buf, size_t len);
virtual const unsigned char *read( void *buf, size_t *inout_len);
- bool valid() { return m_sock >= 0; }
+ bool valid() { return qemu_pipe_valid(m_sock); }
int recv(void *buf, size_t len);
virtual int writeFully(const void *buf, size_t len);
- int getSocket() const;
+ QEMU_PIPE_HANDLE getSocket() const;
private:
- int m_sock;
+ QEMU_PIPE_HANDLE m_sock;
size_t m_bufsize;
unsigned char *m_buf;
- QemuPipeStream(int sock, size_t bufSize);
+ QemuPipeStream(QEMU_PIPE_HANDLE sock, size_t bufSize);
};
#endif
diff --git a/system/OpenglSystemCommon/ThreadInfo.cpp b/system/OpenglSystemCommon/ThreadInfo.cpp
index 425904e..31a8fe9 100644
--- a/system/OpenglSystemCommon/ThreadInfo.cpp
+++ b/system/OpenglSystemCommon/ThreadInfo.cpp
@@ -16,6 +16,9 @@
#include "ThreadInfo.h"
#include "cutils/threads.h"
+#include <bionic_tls.h>
+#include <pthread.h>
+
thread_store_t s_tls = THREAD_STORE_INITIALIZER;
static bool sDefaultTlsDestructorCallback(__attribute__((__unused__)) void* ptr) {
@@ -26,7 +29,10 @@
static void tlsDestruct(void *ptr)
{
sTlsDestructorCallback(ptr);
- if (ptr) {
+ if (ptr
+#ifdef __ANDROID__
+ && ((void **)__get_tls())[TLS_SLOT_OPENGL]) {
+#endif
EGLThreadInfo *ti = (EGLThreadInfo *)ptr;
delete ti->hostConn;
delete ti;
@@ -51,3 +57,21 @@
return ti;
}
+
+EGLThreadInfo* getEGLThreadInfo() {
+#ifdef __ANDROID__
+ EGLThreadInfo *tInfo =
+ (EGLThreadInfo *)(((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL]);
+ if (!tInfo) {
+ tInfo = goldfish_get_egl_tls();
+ ((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL] = (uintptr_t)tInfo;
+ }
+ return tInfo;
+#else
+ return goldfish_get_egl_tls();
+#endif
+}
+
+int32_t getCurrentThreadId() {
+ return (int32_t)gettid();
+}
diff --git a/system/OpenglSystemCommon/ThreadInfo.h b/system/OpenglSystemCommon/ThreadInfo.h
index 57fd5ef..7d2260a 100644
--- a/system/OpenglSystemCommon/ThreadInfo.h
+++ b/system/OpenglSystemCommon/ThreadInfo.h
@@ -17,9 +17,9 @@
#define _THREAD_INFO_H
#include "HostConnection.h"
-#include <pthread.h>
-#include <bionic_tls.h>
+#include <inttypes.h>
+
struct EGLContext_t;
struct EGLThreadInfo
@@ -31,24 +31,13 @@
int eglError;
};
-
typedef bool (*tlsDtorCallback)(void*);
void setTlsDestructor(tlsDtorCallback);
extern "C" __attribute__((visibility("default"))) EGLThreadInfo *goldfish_get_egl_tls();
-inline EGLThreadInfo* getEGLThreadInfo() {
-#ifdef __ANDROID__
- EGLThreadInfo *tInfo =
- (EGLThreadInfo *)(((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL]);
- if (!tInfo) {
- tInfo = goldfish_get_egl_tls();
- ((uintptr_t *)__get_tls())[TLS_SLOT_OPENGL] = (uintptr_t)tInfo;
- }
- return tInfo;
-#else
- return goldfish_get_egl_tls();
-#endif
-}
+EGLThreadInfo* getEGLThreadInfo();
+
+int32_t getCurrentThreadId();
#endif // of _THREAD_INFO_H
diff --git a/system/OpenglSystemCommon/ThreadInfo_host.cpp b/system/OpenglSystemCommon/ThreadInfo_host.cpp
new file mode 100644
index 0000000..0379933
--- /dev/null
+++ b/system/OpenglSystemCommon/ThreadInfo_host.cpp
@@ -0,0 +1,66 @@
+// Copyright 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "ThreadInfo.h"
+
+#include "android/base/memory/LazyInstance.h"
+#include "android/base/threads/Thread.h"
+#include "android/base/threads/ThreadStore.h"
+
+using android::base::LazyInstance;
+using android::base::ThreadStoreBase;
+
+static bool sDefaultTlsDestructorCallback(__attribute__((__unused__)) void* ptr) {
+ return true;
+}
+static bool (*sTlsDestructorCallback)(void*) = sDefaultTlsDestructorCallback;
+
+void setTlsDestructor(tlsDtorCallback func) {
+ sTlsDestructorCallback = func;
+}
+
+static void doTlsDestruct(void* obj) {
+ sTlsDestructorCallback(obj);
+}
+
+class ThreadInfoStore : public ThreadStoreBase {
+public:
+ ThreadInfoStore() : ThreadStoreBase(NULL) { }
+ ~ThreadInfoStore();
+};
+
+static LazyInstance<ThreadInfoStore> sTls = LAZY_INSTANCE_INIT;
+
+ThreadInfoStore::~ThreadInfoStore() {
+ doTlsDestruct(sTls->get());
+}
+
+EGLThreadInfo *goldfish_get_egl_tls()
+{
+ EGLThreadInfo* ti = (EGLThreadInfo*)sTls->get();
+
+ if (ti) return ti;
+
+ ti = new EGLThreadInfo();
+ sTls->set(ti);
+
+ return ti;
+}
+
+EGLThreadInfo* getEGLThreadInfo() {
+ return goldfish_get_egl_tls();
+}
+
+int32_t getCurrentThreadId() {
+ return (int32_t)android::base::getCurrentThreadId();
+}
diff --git a/system/OpenglSystemCommon/VirtioGpuStream.cpp b/system/OpenglSystemCommon/VirtioGpuStream.cpp
new file mode 100644
index 0000000..f6d04d8
--- /dev/null
+++ b/system/OpenglSystemCommon/VirtioGpuStream.cpp
@@ -0,0 +1,439 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "VirtioGpuStream.h"
+
+#include <cros_gralloc_handle.h>
+#include <drm/virtgpu_drm.h>
+#include <xf86drm.h>
+
+#include <sys/types.h>
+#include <sys/mman.h>
+
+#include <errno.h>
+#include <unistd.h>
+
+#ifndef PAGE_SIZE
+#define PAGE_SIZE 0x1000
+#endif
+
+// In a virtual machine, there should only be one GPU
+#define RENDERNODE_MINOR 128
+
+// Maximum size of readback / response buffer in bytes
+#define MAX_CMDRESPBUF_SIZE (10*PAGE_SIZE)
+
+// Attributes use to allocate our response buffer
+// Similar to virgl's fence objects
+#define PIPE_BUFFER 0
+#define VIRGL_FORMAT_R8_UNORM 64
+#define VIRGL_BIND_CUSTOM (1 << 17)
+
+// Conservative; see virgl_winsys.h
+#define VIRGL_MAX_CMDBUF_DWORDS (16*1024)
+#define VIRGL_MAX_CMDBUF_SIZE (4*VIRGL_MAX_CMDBUF_DWORDS)
+
+struct VirtioGpuCmd {
+ uint32_t op;
+ uint32_t cmdSize;
+ unsigned char buf[0];
+} __attribute__((packed));
+
+uint32_t CrosGralloc::getHostHandle(native_handle_t const* handle_)
+{
+ uint32_t id = 0;
+
+ if (m_fd >= 0) {
+ cros_gralloc_handle const* handle =
+ reinterpret_cast<cros_gralloc_handle const*>(handle_);
+ drmPrimeFDToHandle(m_fd, handle->fds[0], &id);
+ }
+
+ return id;
+}
+
+int CrosGralloc::getFormat(native_handle_t const* handle)
+{
+ return ((cros_gralloc_handle *)handle)->droid_format;
+}
+
+bool VirtioGpuProcessPipe::processPipeInit(renderControl_encoder_context_t *rcEnc)
+{
+ union {
+ uint64_t proto;
+ struct {
+ int pid;
+ int tid;
+ } id;
+ } puid = {
+ .id.pid = getpid(),
+ .id.tid = gettid(),
+ };
+ rcEnc->rcSetPuid(rcEnc, puid.proto);
+ return true;
+}
+
+VirtioGpuStream::VirtioGpuStream(size_t bufSize) :
+ IOStream(0U),
+ m_fd(-1),
+ m_bufSize(bufSize),
+ m_buf(nullptr),
+ m_cmdResp_rh(0U),
+ m_cmdResp_bo(0U),
+ m_cmdResp(nullptr),
+ m_cmdRespPos(0U),
+ m_cmdPos(0U),
+ m_flushPos(0U),
+ m_allocSize(0U),
+ m_allocFlushSize(0U)
+{
+}
+
+VirtioGpuStream::~VirtioGpuStream()
+{
+ if (m_cmdResp) {
+ munmap(m_cmdResp, MAX_CMDRESPBUF_SIZE);
+ }
+
+ if (m_cmdResp_bo > 0U) {
+ drm_gem_close gem_close = {
+ .handle = m_cmdResp_bo,
+ };
+ drmIoctl(m_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
+ }
+
+ if (m_fd >= 0) {
+ close(m_fd);
+ }
+
+ free(m_buf);
+}
+
+int VirtioGpuStream::connect()
+{
+ if (m_fd < 0) {
+ m_fd = drmOpenRender(RENDERNODE_MINOR);
+ if (m_fd < 0) {
+ ERR("%s: failed with fd %d (%s)", __func__, m_fd, strerror(errno));
+ return -1;
+ }
+ }
+
+ if (!m_cmdResp_bo) {
+ drm_virtgpu_resource_create create = {
+ .target = PIPE_BUFFER,
+ .format = VIRGL_FORMAT_R8_UNORM,
+ .bind = VIRGL_BIND_CUSTOM,
+ .width = MAX_CMDRESPBUF_SIZE,
+ .height = 1U,
+ .depth = 1U,
+ .array_size = 0U,
+ .size = MAX_CMDRESPBUF_SIZE,
+ .stride = MAX_CMDRESPBUF_SIZE,
+ };
+ int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
+ if (ret) {
+ ERR("%s: failed with %d allocating command response buffer (%s)",
+ __func__, ret, strerror(errno));
+ return -1;
+ }
+ m_cmdResp_bo = create.bo_handle;
+ if (!m_cmdResp_bo) {
+ ERR("%s: no handle when allocating command response buffer",
+ __func__);
+ return -1;
+ }
+ m_cmdResp_rh = create.res_handle;
+ if (create.size != MAX_CMDRESPBUF_SIZE) {
+ ERR("%s: command response buffer wrongly sized, create.size=%zu "
+ "!= %zu", __func__,
+ static_cast<size_t>(create.size),
+ static_cast<size_t>(MAX_CMDRESPBUF_SIZE));
+ abort();
+ }
+ }
+
+ if (!m_cmdResp) {
+ drm_virtgpu_map map = {
+ .handle = m_cmdResp_bo,
+ };
+ int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_MAP, &map);
+ if (ret) {
+ ERR("%s: failed with %d mapping command response buffer (%s)",
+ __func__, ret, strerror(errno));
+ return -1;
+ }
+ m_cmdResp = static_cast<VirtioGpuCmd *>(mmap64(nullptr,
+ MAX_CMDRESPBUF_SIZE,
+ PROT_READ, MAP_SHARED,
+ m_fd, map.offset));
+ if (m_cmdResp == MAP_FAILED) {
+ ERR("%s: failed with %d mmap'ing command response buffer (%s)",
+ __func__, ret, strerror(errno));
+ return -1;
+ }
+ }
+
+ m_gralloc.setFd(m_fd);
+ return 0;
+}
+
+int VirtioGpuStream::flush()
+{
+ int ret = commitBuffer(m_allocSize - m_allocFlushSize);
+ if (ret)
+ return ret;
+ m_allocFlushSize = m_allocSize;
+ return 0;
+}
+
+void *VirtioGpuStream::allocBuffer(size_t minSize)
+{
+ if (m_buf) {
+ // Try to model the alloc() calls being made by the user. They should be
+ // obeying the protocol and using alloc() for anything they don't write
+ // with writeFully(), so we can know if this alloc() is for part of a
+ // command, or not. If it is not for part of a command, we are starting
+ // a new command, and should increment m_cmdPos.
+ VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
+ if (m_allocSize + minSize > cmd->cmdSize) {
+ m_allocFlushSize = 0U;
+ m_allocSize = 0U;
+ // This might also be a convenient point to flush commands
+ if (m_cmdPos + cmd->cmdSize + minSize > m_bufSize) {
+ if (commitAll() < 0) {
+ ERR("%s: command flush failed", __func__);
+ m_flushPos = 0U;
+ m_bufSize = 0U;
+ m_cmdPos = 0U;
+ free(m_buf);
+ m_buf = nullptr;
+ return nullptr;
+ }
+ } else {
+ m_cmdPos += cmd->cmdSize;
+ m_flushPos = m_cmdPos;
+ }
+ }
+ }
+
+ // Update m_allocSize here, before minSize is tampered with below
+ m_allocSize += minSize;
+
+ // Make sure anything we already have written to the buffer is retained
+ minSize += m_flushPos;
+
+ size_t allocSize = (m_bufSize < minSize ? minSize : m_bufSize);
+ if (!m_buf) {
+ m_buf = static_cast<unsigned char *>(malloc(allocSize));
+ } else if (m_bufSize < allocSize) {
+ unsigned char *p = static_cast<unsigned char *>(realloc(m_buf, allocSize));
+ if (!p) {
+ free(m_buf);
+ }
+ m_buf = p;
+ }
+ if (!m_buf) {
+ ERR("%s: alloc (%zu) failed\n", __func__, allocSize);
+ m_allocFlushSize = 0U;
+ m_allocSize = 0U;
+ m_flushPos = 0U;
+ m_bufSize = 0U;
+ m_cmdPos = 0U;
+ } else {
+ m_bufSize = allocSize;
+ }
+ if (m_flushPos == 0 && m_cmdPos == 0) {
+ // During initialization, HostConnection will send an empty command
+ // packet to check the connection is good, but it doesn't obey the usual
+ // line protocol. This is a 4 byte write to [0], which is our 'op' field,
+ // and we don't have an op=0 so it's OK. We fake up a valid length, and
+ // overload this workaround by putting the res_handle for the readback
+ // buffer in the command payload, patched in just before we submit.
+ VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
+ cmd->op = 0U;
+ cmd->cmdSize = sizeof(*cmd) + sizeof(__u32);
+ }
+ return m_buf + m_cmdPos;
+}
+
+// For us, writeFully() means to write a command without any header, directly
+// into the buffer stream. We can use the packet frame written directly to the
+// stream to verify this write is within bounds, then update the counter.
+
+int VirtioGpuStream::writeFully(const void *buf, size_t len)
+{
+ if (!valid())
+ return -1;
+
+ if (!buf) {
+ if (len > 0) {
+ // If len is non-zero, buf must not be NULL. Otherwise the pipe would
+ // be in a corrupted state, which is lethal for the emulator.
+ ERR("%s: failed, buf=NULL, len %zu, lethal error, exiting",
+ __func__, len);
+ abort();
+ }
+ return 0;
+ }
+
+ VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
+
+ if (m_flushPos < sizeof(*cmd)) {
+ ERR("%s: writeFully len %zu would overwrite command header, "
+ "cmd_pos=%zu, flush_pos=%zu, lethal error, exiting", __func__,
+ len, m_cmdPos, m_flushPos);
+ abort();
+ }
+
+ if (m_flushPos + len > cmd->cmdSize) {
+ ERR("%s: writeFully len %zu would overflow the command bounds, "
+ "cmd_pos=%zu, flush_pos=%zu, cmdsize=%zu, lethal error, exiting",
+ __func__, len, m_cmdPos, m_flushPos, cmd->cmdSize);
+ abort();
+ }
+
+ if (len > VIRGL_MAX_CMDBUF_SIZE) {
+ ERR("%s: Large command (%zu bytes) exceeds virgl limits",
+ __func__, len);
+ /* Fall through */
+ }
+
+ memcpy(&m_buf[m_flushPos], buf, len);
+ commitBuffer(len);
+ m_allocSize += len;
+ return 0;
+}
+
+const unsigned char *VirtioGpuStream::readFully(void *buf, size_t len)
+{
+ if (!valid())
+ return nullptr;
+
+ if (!buf) {
+ if (len > 0) {
+ // If len is non-zero, buf must not be NULL. Otherwise the pipe would
+ // be in a corrupted state, which is lethal for the emulator.
+ ERR("%s: failed, buf=NULL, len %zu, lethal error, exiting.",
+ __func__, len);
+ abort();
+ }
+ return nullptr;
+ }
+
+ // Read is too big for current architecture
+ if (len > MAX_CMDRESPBUF_SIZE - sizeof(*m_cmdResp)) {
+ ERR("%s: failed, read too large, len %zu, lethal error, exiting.",
+ __func__, len);
+ abort();
+ }
+
+ // Commit all outstanding write commands (if any)
+ if (commitAll() < 0) {
+ ERR("%s: command flush failed", __func__);
+ return nullptr;
+ }
+
+ if (len > 0U && m_cmdRespPos == 0U) {
+ // When we are about to read for the first time, wait for the virtqueue
+ // to drain to this command, otherwise the data could be stale
+ drm_virtgpu_3d_wait wait = {
+ .handle = m_cmdResp_bo,
+ };
+ int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_WAIT, &wait);
+ if (ret) {
+ ERR("%s: failed with %d waiting for response buffer (%s)",
+ __func__, ret, strerror(errno));
+ // Fall through, hope for the best
+ }
+ }
+
+ // Most likely a protocol implementation error
+ if (m_cmdResp->cmdSize - sizeof(*m_cmdResp) < m_cmdRespPos + len) {
+ ERR("%s: failed, op %zu, len %zu, cmdSize %zu, pos %zu, lethal "
+ "error, exiting.", __func__, m_cmdResp->op, len,
+ m_cmdResp->cmdSize, m_cmdRespPos);
+ abort();
+ }
+
+ memcpy(buf, &m_cmdResp->buf[m_cmdRespPos], len);
+
+ if (m_cmdRespPos + len == m_cmdResp->cmdSize - sizeof(*m_cmdResp)) {
+ m_cmdRespPos = 0U;
+ } else {
+ m_cmdRespPos += len;
+ }
+
+ return reinterpret_cast<const unsigned char *>(buf);
+}
+
+int VirtioGpuStream::commitBuffer(size_t size)
+{
+ if (m_flushPos + size > m_bufSize) {
+ ERR("%s: illegal commit size %zu, flushPos %zu, bufSize %zu",
+ __func__, size, m_flushPos, m_bufSize);
+ return -1;
+ }
+ m_flushPos += size;
+ return 0;
+}
+
+int VirtioGpuStream::commitAll()
+{
+ size_t pos = 0U, numFlushed = 0U;
+ while (pos < m_flushPos) {
+ VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[pos]);
+
+ // Should never happen
+ if (pos + cmd->cmdSize > m_bufSize) {
+ ERR("%s: failed, pos %zu, cmdSize %zu, bufSize %zu, lethal "
+ "error, exiting.", __func__, pos, cmd->cmdSize, m_bufSize);
+ abort();
+ }
+
+ // Saw dummy command; patch it with res handle
+ if (cmd->op == 0) {
+ *(uint32_t *)cmd->buf = m_cmdResp_rh;
+ }
+
+ // Flush a single command
+ drm_virtgpu_execbuffer execbuffer = {
+ .size = cmd->cmdSize,
+ .command = reinterpret_cast<__u64>(cmd),
+ .bo_handles = reinterpret_cast<__u64>(&m_cmdResp_bo),
+ .num_bo_handles = 1U,
+ };
+ int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
+ if (ret) {
+ ERR("%s: failed with %d executing command buffer (%s)", __func__,
+ ret, strerror(errno));
+ return -1;
+ }
+
+ pos += cmd->cmdSize;
+ numFlushed++;
+ }
+
+ if (pos > m_flushPos) {
+ ERR("%s: aliasing, flushPos %zu, pos %zu, probably ok", __func__,
+ m_flushPos, pos);
+ /* Fall through */
+ }
+
+ m_flushPos = 0U;
+ m_cmdPos = 0U;
+ return 0;
+}
diff --git a/system/OpenglSystemCommon/VirtioGpuStream.h b/system/OpenglSystemCommon/VirtioGpuStream.h
new file mode 100644
index 0000000..9d6faa5
--- /dev/null
+++ b/system/OpenglSystemCommon/VirtioGpuStream.h
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "HostConnection.h"
+#include "IOStream.h"
+
+#include <stdlib.h>
+
+/* This file implements an IOStream that uses VIRTGPU_EXECBUFFER ioctls on a
+ * virtio-gpu DRM rendernode device to communicate with the host.
+ */
+
+struct VirtioGpuCmd;
+
+class CrosGralloc : public Gralloc
+{
+ friend class VirtioGpuStream;
+
+public:
+ virtual uint32_t getHostHandle(native_handle_t const* handle);
+ virtual int getFormat(native_handle_t const* handle);
+
+private:
+ inline void setFd(int fd) { m_fd = fd; }
+ int m_fd = -1;
+};
+
+class VirtioGpuProcessPipe : public ProcessPipe
+{
+public:
+ virtual bool processPipeInit(renderControl_encoder_context_t *rcEnc);
+};
+
+class VirtioGpuStream : public IOStream
+{
+public:
+ explicit VirtioGpuStream(size_t bufSize);
+ ~VirtioGpuStream();
+
+ int connect();
+ Gralloc *getGralloc() { return &m_gralloc; }
+ ProcessPipe *getProcessPipe() { return &m_processPipe; }
+
+ // override IOStream so we can see non-rounded allocation sizes
+ virtual unsigned char *alloc(size_t len)
+ {
+ return static_cast<unsigned char *>(allocBuffer(len));
+ }
+
+ // override IOStream so we can model the caller's writes
+ virtual int flush();
+
+ virtual void *allocBuffer(size_t minSize);
+ virtual int writeFully(const void *buf, size_t len);
+ virtual const unsigned char *readFully(void *buf, size_t len);
+ virtual int commitBuffer(size_t size);
+ virtual const unsigned char *read(void *buf, size_t *inout_len) final
+ {
+ return readFully(buf, *inout_len);
+ }
+
+ bool valid()
+ {
+ return m_fd >= 0 && m_cmdResp_bo > 0 && m_cmdResp;
+ }
+
+private:
+ // rendernode fd
+ int m_fd;
+
+ // command memory buffer
+ size_t m_bufSize;
+ unsigned char *m_buf;
+
+ // response buffer res handle
+ uint32_t m_cmdResp_rh;
+
+ // response buffer ttm buffer object
+ uint32_t m_cmdResp_bo;
+
+ // user mapping of response buffer object
+ VirtioGpuCmd *m_cmdResp;
+
+ // byte offset to read cursor for last response
+ size_t m_cmdRespPos;
+
+ // byte offset to command being assembled
+ size_t m_cmdPos;
+
+ // byte offset to flush cursor
+ size_t m_flushPos;
+
+ // byte counter of allocs since last command boundary
+ size_t m_allocSize;
+
+ // bytes of an alloc flushed through flush() API
+ size_t m_allocFlushSize;
+
+ // CrOS gralloc interface
+ CrosGralloc m_gralloc;
+
+ // Fake process pipe implementation
+ VirtioGpuProcessPipe m_processPipe;
+
+ // commits all commands, resets buffer offsets
+ int commitAll();
+};
diff --git a/system/OpenglSystemCommon/goldfish_dma.h b/system/OpenglSystemCommon/goldfish_dma.h
deleted file mode 100644
index 6c1b09a..0000000
--- a/system/OpenglSystemCommon/goldfish_dma.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2016 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- */
-
-#ifndef ANDROID_INCLUDE_HARDWARE_GOLDFISH_DMA_H
-#define ANDROID_INCLUDE_HARDWARE_GOLDFISH_DMA_H
-
-#include <errno.h>
-#include <linux/ioctl.h>
-#include <linux/types.h>
-#include <sys/cdefs.h>
-#include <fcntl.h>
-#include <stdlib.h>
-
-/* There is an ioctl associated with goldfish dma driver.
- * Make it conflict with ioctls that are not likely to be used
- * in the emulator.
- * 'G' 00-3F drivers/misc/sgi-gru/grulib.h conflict!
- * 'G' 00-0F linux/gigaset_dev.h conflict!
- */
-#define GOLDFISH_DMA_IOC_MAGIC 'G'
-
-#define GOLDFISH_DMA_IOC_LOCK _IOWR(GOLDFISH_DMA_IOC_MAGIC, 0, struct goldfish_dma_ioctl_info)
-#define GOLDFISH_DMA_IOC_UNLOCK _IOWR(GOLDFISH_DMA_IOC_MAGIC, 1, struct goldfish_dma_ioctl_info)
-#define GOLDFISH_DMA_IOC_GETOFF _IOWR(GOLDFISH_DMA_IOC_MAGIC, 2, struct goldfish_dma_ioctl_info)
-#define GOLDFISH_DMA_IOC_CREATE_REGION _IOWR(GOLDFISH_DMA_IOC_MAGIC, 3, struct goldfish_dma_ioctl_info)
-
-struct goldfish_dma_ioctl_info {
- uint64_t phys_begin;
- uint64_t size;
-};
-
-// userspace interface
-struct goldfish_dma_context {
- uint64_t mapped_addr;
- uint32_t size;
- int32_t fd;
-};
-
-int goldfish_dma_lock(struct goldfish_dma_context* cxt);
-int goldfish_dma_unlock(struct goldfish_dma_context* cxt);
-int goldfish_dma_create_region(uint32_t sz, struct goldfish_dma_context* res);
-
-void* goldfish_dma_map(struct goldfish_dma_context* cxt);
-int goldfish_dma_unmap(struct goldfish_dma_context* cxt);
-
-void goldfish_dma_write(struct goldfish_dma_context* cxt,
- const void* to_write,
- uint32_t sz);
-
-void goldfish_dma_free(goldfish_dma_context* cxt);
-uint64_t goldfish_dma_guest_paddr(struct goldfish_dma_context* cxt);
-
-#endif
diff --git a/system/egl/Android.mk b/system/egl/Android.mk
index 9864e13..80778bd 100644
--- a/system/egl/Android.mk
+++ b/system/egl/Android.mk
@@ -13,27 +13,27 @@
egl.cpp \
ClientAPIExts.cpp
-ifdef IS_AT_LEAST_OPD1
-LOCAL_SHARED_LIBRARIES += libdl libnativewindow
-else
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
LOCAL_SHARED_LIBRARIES += libdl
endif
-ifdef IS_AT_LEAST_OPD1
-LOCAL_STATIC_LIBRARIES += libarect
-endif
-
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
ifdef IS_AT_LEAST_OPM1
LOCAL_HEADER_LIBRARIES += libui_headers
endif
ifdef IS_AT_LEAST_OPD1
LOCAL_HEADER_LIBRARIES += libnativebase_headers
+LOCAL_STATIC_LIBRARIES += libarect
+LOCAL_SHARED_LIBRARIES += libnativewindow
endif
# Used to access the Bionic private OpenGL TLS slot
LOCAL_C_INCLUDES += bionic/libc/private
+endif # !GOLDFISH_OPENGL_BUILD_FOR_HOST
+
$(call emugl-end-module)
#### egl.cfg ####
diff --git a/system/egl/CMakeLists.txt b/system/egl/CMakeLists.txt
new file mode 100644
index 0000000..56f92cd
--- /dev/null
+++ b/system/egl/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/egl/Android.mk" "4a6be27a2b501a86cad12c5876d0e766966574b11376ff8614fd92ffe94eb4b3")
+set(EGL_emulation_src eglDisplay.cpp egl.cpp ClientAPIExts.cpp)
+android_add_shared_library(EGL_emulation)
+target_include_directories(EGL_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(EGL_emulation PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"EGL_emulation\"" "-DEGL_EGLEXT_PROTOTYPES")
+target_compile_options(EGL_emulation PRIVATE "-fvisibility=default")
+target_link_libraries(EGL_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/egl/ClientAPIExts.cpp b/system/egl/ClientAPIExts.cpp
index 0f02dcb..40644e7 100644
--- a/system/egl/ClientAPIExts.cpp
+++ b/system/egl/ClientAPIExts.cpp
@@ -97,7 +97,8 @@
if (!thread->currentContext) { \
return; \
} \
- int idx = (int)thread->currentContext->majorVersion - 1; \
+ int clientMajorVersion = (int)thread->currentContext->majorVersion; \
+ int idx = clientMajorVersion == 1 ? 0 : 1; \
if (!s_client_extensions[idx].fname) { \
return; \
} \
diff --git a/system/egl/ClientAPIExts.in b/system/egl/ClientAPIExts.in
index 5850701..a4595f2 100644
--- a/system/egl/ClientAPIExts.in
+++ b/system/egl/ClientAPIExts.in
@@ -199,3 +199,27 @@
API_ENTRY(glDrawTexxvOES,
(const GLfixed *coords),
(coords))
+
+API_ENTRY(glBindVertexArrayOES,
+ (GLuint array),
+ (array))
+
+API_ENTRY(glDeleteVertexArraysOES,
+ (GLsizei n, const GLuint* arrays),
+ (n, arrays))
+
+API_ENTRY(glGenVertexArraysOES,
+ (GLsizei n, GLuint* arrays),
+ (n, arrays))
+
+API_ENTRY(glIsVertexArrayOES,
+ (GLuint array),
+ (array))
+
+API_ENTRY(glMapBufferOES,
+ (GLenum target, GLenum access),
+ (target, access))
+
+API_ENTRY(glUnmapBufferOES,
+ (GLenum target),
+ (target))
\ No newline at end of file
diff --git a/system/egl/egl.cpp b/system/egl/egl.cpp
index e52c5bd..23fb8cc 100644
--- a/system/egl/egl.cpp
+++ b/system/egl/egl.cpp
@@ -23,13 +23,13 @@
#include <cutils/log.h>
#include <cutils/properties.h>
#include "goldfish_sync.h"
-#include "gralloc_cb.h"
#include "GLClientState.h"
#include "GLSharedGroup.h"
#include "eglContext.h"
#include "ClientAPIExts.h"
#include "EGLImage.h"
#include "ProcessPipe.h"
+#include "qemu_pipe.h"
#include "GLEncoder.h"
#ifdef WITH_GLES2
@@ -96,12 +96,12 @@
#define setErrorReturn(error, retVal) \
{ \
- ALOGE("tid %d: %s(%d): error 0x%x (%s)", gettid(), __FUNCTION__, __LINE__, error, eglStrError(error)); \
+ ALOGE("tid %d: %s(%d): error 0x%x (%s)", getCurrentThreadId(), __FUNCTION__, __LINE__, error, eglStrError(error)); \
return setErrorFunc(error, retVal); \
}
#define RETURN_ERROR(ret,err) \
- ALOGE("tid %d: %s(%d): error 0x%x (%s)", gettid(), __FUNCTION__, __LINE__, err, eglStrError(err)); \
+ ALOGE("tid %d: %s(%d): error 0x%x (%s)", getCurrentThreadId(), __FUNCTION__, __LINE__, err, eglStrError(err)); \
getEGLThreadInfo()->eglError = err; \
return ret;
@@ -145,6 +145,11 @@
if (!rcEnc) { \
ALOGE("egl: Failed to get renderControl encoder context\n"); \
return ret; \
+ } \
+ Gralloc *grallocHelper = hostCon->grallocHelper(); \
+ if (!grallocHelper) { \
+ ALOGE("egl: Failed to get grallocHelper\n"); \
+ return ret; \
}
#define DEFINE_AND_VALIDATE_HOST_CONNECTION_FOR_TLS(ret, tls) \
@@ -157,6 +162,11 @@
if (!rcEnc) { \
ALOGE("egl: Failed to get renderControl encoder context\n"); \
return ret; \
+ } \
+ Gralloc const* grallocHelper = hostCon->grallocHelper(); \
+ if (!grallocHelper) { \
+ ALOGE("egl: Failed to get grallocHelper\n"); \
+ return ret; \
}
#define VALIDATE_CONTEXT_RETURN(context,ret) \
@@ -396,12 +406,13 @@
DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uintptr_t)config,
getWidth(), getHeight());
+
if (!rcSurface) {
ALOGE("rcCreateWindowSurface returned 0");
return EGL_FALSE;
}
rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface,
- ((cb_handle_t*)(buffer->handle))->hostHandle);
+ grallocHelper->getHostHandle(buffer->handle));
return EGL_TRUE;
}
@@ -424,6 +435,7 @@
if (rcSurface && rcEnc) {
rcEnc->rcDestroyWindowSurface(rcEnc, rcSurface);
}
+
if (buffer) {
nativeWindow->cancelBuffer_DEPRECATED(nativeWindow, buffer);
}
@@ -468,6 +480,8 @@
thread_handle,
fd_out);
+ (void)queue_work_err;
+
DPRINT("got native fence fd=%d queue_work_err=%d",
*fd_out, queue_work_err);
}
@@ -560,7 +574,7 @@
#endif
rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface,
- ((cb_handle_t *)(buffer->handle))->hostHandle);
+ grallocHelper->getHostHandle(buffer->handle));
setWidth(buffer->width);
setHeight(buffer->height);
@@ -588,12 +602,13 @@
EGLBoolean init(GLenum format);
uint32_t rcColorBuffer;
+ QEMU_PIPE_HANDLE refcountPipeFd;
};
egl_pbuffer_surface_t::egl_pbuffer_surface_t(EGLDisplay dpy, EGLConfig config,
EGLint surfType, int32_t w, int32_t h)
: egl_surface_t(dpy, config, surfType),
- rcColorBuffer(0)
+ rcColorBuffer(0), refcountPipeFd(QEMU_PIPE_INVALID_HANDLE)
{
setWidth(w);
setHeight(h);
@@ -603,7 +618,13 @@
{
DEFINE_HOST_CONNECTION;
if (rcEnc) {
- if (rcColorBuffer) rcEnc->rcCloseColorBuffer(rcEnc, rcColorBuffer);
+ if (rcColorBuffer){
+ if(qemu_pipe_valid(refcountPipeFd)) {
+ qemu_pipe_close(refcountPipeFd);
+ } else {
+ rcEnc->rcCloseColorBuffer(rcEnc, rcColorBuffer);
+ }
+ }
if (rcSurface) rcEnc->rcDestroyWindowSurface(rcEnc, rcSurface);
}
}
@@ -611,7 +632,10 @@
// Destroy a pending surface and set it to NULL.
static void s_destroyPendingSurfaceAndSetNull(EGLSurface* surface) {
- if (!s_display.isSurface(surface)) {
+ if (!surface)
+ return;
+
+ if (!s_display.isSurface(*surface)) {
*surface = NULL;
return;
}
@@ -651,6 +675,12 @@
if (!rcColorBuffer) {
ALOGE("rcCreateColorBuffer returned 0");
return EGL_FALSE;
+ } else {
+ refcountPipeFd = qemu_pipe_open("refcount");
+ //Send color buffer handle in case RefCountPipe feature is turned on.
+ if (qemu_pipe_valid(refcountPipeFd)) {
+ qemu_pipe_write(refcountPipeFd, &rcColorBuffer, 4);
+ }
}
rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, rcColorBuffer);
@@ -1274,7 +1304,10 @@
tInfo->eglError = EGL_SUCCESS;
EGLContext_t* context = tInfo->currentContext;
- if (!context || !s_display.isContext(context)) return EGL_TRUE;
+ if (!context || !s_display.isContext(context)) {
+ HostConnection::exit();
+ return EGL_TRUE;
+ }
// The following code is doing pretty much the same thing as
// eglMakeCurrent(&s_display, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE)
@@ -1296,6 +1329,8 @@
}
tInfo->currentContext = 0;
+ HostConnection::exit();
+
return EGL_TRUE;
}
@@ -1948,9 +1983,9 @@
if (native_buffer->common.version != sizeof(android_native_buffer_t))
setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
- cb_handle_t *cb = (cb_handle_t *)(native_buffer->handle);
-
- switch (cb->format) {
+ DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
+ int format = grallocHelper->getFormat(native_buffer->handle);
+ switch (format) {
case HAL_PIXEL_FORMAT_RGBA_8888:
case HAL_PIXEL_FORMAT_RGBX_8888:
case HAL_PIXEL_FORMAT_RGB_888:
diff --git a/system/egl/eglDisplay.cpp b/system/egl/eglDisplay.cpp
index f593598..70ee096 100644
--- a/system/egl/eglDisplay.cpp
+++ b/system/egl/eglDisplay.cpp
@@ -15,10 +15,17 @@
*/
#include "eglDisplay.h"
#include "HostConnection.h"
-#include <dlfcn.h>
+#include "KeyedVectorUtils.h"
+
+#ifdef HOST_BUILD
+#include "android/base/files/PathUtils.cpp"
+#include "android/base/system/System.cpp"
+#endif
#include <string>
+#include <dlfcn.h>
+
static const int systemEGLVersionMajor = 1;
static const int systemEGLVersionMinor = 4;
static const char systemEGLVendor[] = "Google Android emulator";
@@ -60,7 +67,7 @@
m_hostRendererVersion(0),
m_numConfigs(0),
m_numConfigAttribs(0),
- m_attribs(DefaultKeyedVector<EGLint, EGLint>(ATTRIBUTE_NONE)),
+ m_attribs(),
m_configs(NULL),
m_gles_iface(NULL),
m_gles2_iface(NULL),
@@ -81,11 +88,7 @@
pthread_mutex_destroy(&m_surfaceLock);
}
-#if PLATFORM_SDK_VERSION >= 26
-#define PARTITION "/vendor"
-#else
-#define PARTITION "/system"
-#endif
+
bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
{
@@ -95,15 +98,9 @@
//
// load GLES client API
//
-#if __LP64__
- m_gles_iface = loadGLESClientAPI(PARTITION "/lib64/egl/libGLESv1_CM_emulation.so",
+ m_gles_iface = loadGLESClientAPI("libGLESv1_CM_emulation",
eglIface,
&s_gles_lib);
-#else
- m_gles_iface = loadGLESClientAPI(PARTITION "/lib/egl/libGLESv1_CM_emulation.so",
- eglIface,
- &s_gles_lib);
-#endif
if (!m_gles_iface) {
pthread_mutex_unlock(&m_lock);
ALOGE("Failed to load gles1 iface");
@@ -111,15 +108,9 @@
}
#ifdef WITH_GLES2
-#if __LP64__
- m_gles2_iface = loadGLESClientAPI(PARTITION "/lib64/egl/libGLESv2_emulation.so",
+ m_gles2_iface = loadGLESClientAPI("libGLESv2_emulation",
eglIface,
&s_gles2_lib);
-#else
- m_gles2_iface = loadGLESClientAPI(PARTITION "/lib/egl/libGLESv2_emulation.so",
- eglIface,
- &s_gles2_lib);
-#endif
// Note that if loading gles2 failed, we can still run with no
// GLES2 support, having GLES2 is not mandatory.
#endif
@@ -186,21 +177,20 @@
return false;
}
- //EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), m_configs);
EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), (GLuint*)tmp_buf);
if (n != m_numConfigs) {
pthread_mutex_unlock(&m_lock);
return false;
}
- //Fill the attributes vector.
- //The first m_numConfigAttribs values of tmp_buf are the actual attributes enums.
+ // Fill the attributes vector.
+ // The first m_numConfigAttribs values of tmp_buf are the actual attributes enums.
for (int i=0; i<m_numConfigAttribs; i++) {
- m_attribs.add(tmp_buf[i], i);
+ m_attribs[tmp_buf[i]] = i;
}
- //Copy the actual configs data to m_configs
- memcpy(m_configs, tmp_buf + m_numConfigAttribs, m_numConfigs*m_numConfigAttribs*sizeof(EGLint));
+ memcpy(m_configs, tmp_buf + m_numConfigAttribs,
+ m_numConfigs*m_numConfigAttribs*sizeof(EGLint));
m_initialized = true;
}
@@ -215,7 +205,6 @@
{
for (intptr_t i=0; i<m_numConfigs; i++) {
EGLConfig config = (EGLConfig)i;
- //Setup the EGL_NATIVE_VISUAL_ID attribute
PixelFormat format;
if (getConfigNativePixelFormat(config, &format)) {
setConfigAttrib(config, EGL_NATIVE_VISUAL_ID, format);
@@ -261,13 +250,50 @@
pthread_mutex_unlock(&m_lock);
}
-EGLClient_glesInterface *eglDisplay::loadGLESClientAPI(const char *libName,
+#ifdef __APPLE__
+#define LIBSUFFIX ".dylib"
+#else
+#ifdef _WIN32
+#define LIBSUFFIX ".dll"
+#else
+#define LIBSUFFIX ".so"
+#endif // !_WIN32 (linux)
+#endif // !__APPLE__
+
+#ifndef HOST_BUILD
+#if PLATFORM_SDK_VERSION >= 26
+#define PARTITION "/vendor"
+#else
+#define PARTITION "/system"
+#endif // !PLATFORM_SDK_VERSION >= 26
+#if __LP64__
+#define LIBDIR "/lib64/egl/"
+#else
+#define LIBDIR "/lib/egl/"
+#endif // !__LP64__
+#endif // !HOST_BUILD
+
+EGLClient_glesInterface *eglDisplay::loadGLESClientAPI(const char *basename,
EGLClient_eglInterface *eglIface,
void **libHandle)
{
- void *lib = dlopen(libName, RTLD_NOW);
+#ifdef HOST_BUILD
+ std::string baseDir =
+ android::base::System::get()->getProgramDirectory();
+ std::string path =
+ android::base::pj(
+ baseDir, "lib64", std::string(basename) + LIBSUFFIX);
+ void *lib = dlopen(path.c_str(), RTLD_NOW);
+#else
+ std::string path(PARTITION);
+ path += LIBDIR;
+ path += basename;
+ path += LIBSUFFIX;
+ void *lib = dlopen(path.c_str(), RTLD_NOW);
+#endif
+
if (!lib) {
- ALOGE("Failed to dlopen %s", libName);
+ ALOGE("Failed to dlopen %s", basename);
return NULL;
}
@@ -462,7 +488,12 @@
}
//Though it seems that valueFor() is thread-safe, we don't take chanses
pthread_mutex_lock(&m_lock);
- EGLBoolean ret = getAttribValue(config, m_attribs.valueFor(attrib), value);
+ EGLBoolean ret =
+ getAttribValue(
+ config,
+ findObjectOrDefault(
+ m_attribs, attrib, EGL_DONT_CARE),
+ value);
pthread_mutex_unlock(&m_lock);
return ret;
}
@@ -495,7 +526,14 @@
{
//Though it seems that valueFor() is thread-safe, we don't take chanses
pthread_mutex_lock(&m_lock);
- EGLBoolean ret = setAttribValue(config, m_attribs.valueFor(attrib), value);
+ EGLBoolean ret =
+ setAttribValue(
+ config,
+ findObjectOrDefault(
+ m_attribs,
+ attrib,
+ EGL_DONT_CARE),
+ value);
pthread_mutex_unlock(&m_lock);
return ret;
}
@@ -505,11 +543,23 @@
{
EGLint redSize, blueSize, greenSize, alphaSize;
- if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
- getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
- getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
- getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
- {
+ if (!(
+ getAttribValue(
+ config,
+ findObjectOrDefault(m_attribs, EGL_RED_SIZE, EGL_DONT_CARE),
+ &redSize) &&
+ getAttribValue(
+ config,
+ findObjectOrDefault(m_attribs, EGL_BLUE_SIZE, EGL_DONT_CARE),
+ &blueSize) &&
+ getAttribValue(
+ config,
+ findObjectOrDefault(m_attribs, EGL_GREEN_SIZE, EGL_DONT_CARE),
+ &greenSize) &&
+ getAttribValue(
+ config,
+ findObjectOrDefault(m_attribs, EGL_ALPHA_SIZE, EGL_DONT_CARE),
+ &alphaSize))) {
ALOGE("Couldn't find value for one of the pixel format attributes");
return EGL_FALSE;
}
@@ -529,11 +579,23 @@
{
EGLint redSize, blueSize, greenSize, alphaSize;
- if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
- getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
- getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
- getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
- {
+ if (!(
+ getAttribValue(
+ config,
+ findObjectOrDefault(m_attribs, EGL_RED_SIZE, EGL_DONT_CARE),
+ &redSize) &&
+ getAttribValue(
+ config,
+ findObjectOrDefault(m_attribs, EGL_BLUE_SIZE, EGL_DONT_CARE),
+ &blueSize) &&
+ getAttribValue(
+ config,
+ findObjectOrDefault(m_attribs, EGL_GREEN_SIZE, EGL_DONT_CARE),
+ &greenSize) &&
+ getAttribValue(
+ config,
+ findObjectOrDefault(m_attribs, EGL_ALPHA_SIZE, EGL_DONT_CARE),
+ &alphaSize))) {
ALOGE("Couldn't find value for one of the pixel format attributes");
return EGL_FALSE;
}
diff --git a/system/egl/eglDisplay.h b/system/egl/eglDisplay.h
index 9fb6f07..2394da1 100644
--- a/system/egl/eglDisplay.h
+++ b/system/egl/eglDisplay.h
@@ -16,12 +16,12 @@
#ifndef _SYSTEM_EGL_DISPLAY_H
#define _SYSTEM_EGL_DISPLAY_H
+#include <assert.h>
#include <pthread.h>
#include "glUtils.h"
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include "EGLClientIface.h"
-#include <utils/KeyedVector.h>
#if __cplusplus >= 201103L
#include <unordered_set>
@@ -29,6 +29,7 @@
#include <hash_set>
#endif
+#include <map>
#include <ui/PixelFormat.h>
@@ -88,7 +89,7 @@
int m_numConfigAttribs;
/* This is the mapping between an attribute name to it's index in any given config */
- DefaultKeyedVector<EGLint, EGLint> m_attribs;
+ std::map<EGLint, EGLint> m_attribs;
/* This is an array of all config's attributes values stored in the following sequencial fasion (read: v[c,a] = the value of attribute <a> of config <c>)
* v[0,0],..,v[0,m_numConfigAttribs-1],
*...
diff --git a/system/egl/goldfish_sync.h b/system/egl/goldfish_sync.h
index 5dcc449..ec29bee 100644
--- a/system/egl/goldfish_sync.h
+++ b/system/egl/goldfish_sync.h
@@ -15,6 +15,26 @@
#ifndef ANDROID_INCLUDE_HARDWARE_GOLDFISH_SYNC_H
#define ANDROID_INCLUDE_HARDWARE_GOLDFISH_SYNC_H
+#ifdef HOST_BUILD
+
+static __inline__ int goldfish_sync_open() {
+ return 0;
+}
+
+static __inline__ int goldfish_sync_close(int sync_fd) {
+ return 0;
+}
+
+static __inline__ int goldfish_sync_queue_work(int goldfish_sync_fd,
+ uint64_t host_glsync,
+ uint64_t host_thread,
+ int* fd_out) {
+ return 0;
+}
+
+#else
+
+#include <errno.h>
#include <linux/ioctl.h>
#include <linux/types.h>
#include <sys/cdefs.h>
@@ -79,4 +99,6 @@
return err;
}
+#endif // !HOST_BUILD
+
#endif
diff --git a/system/enc_common/IOStream_common.cpp b/system/enc_common/IOStream_common.cpp
index 43f03af..901ad1d 100644
--- a/system/enc_common/IOStream_common.cpp
+++ b/system/enc_common/IOStream_common.cpp
@@ -6,6 +6,8 @@
#include <vector>
+#include <assert.h>
+
void IOStream::readbackPixels(void* context, int width, int height, unsigned int format, unsigned int type, void* pixels) {
GL2Encoder *ctx = (GL2Encoder *)context;
assert (ctx->state() != NULL);
diff --git a/system/gralloc/Android.mk b/system/gralloc/Android.mk
index 190bfd6..88dd193 100644
--- a/system/gralloc/Android.mk
+++ b/system/gralloc/Android.mk
@@ -12,9 +12,11 @@
LOCAL_SRC_FILES := gralloc.cpp
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
# Need to access the special OPENGL TLS Slot
LOCAL_C_INCLUDES += bionic/libc/private
LOCAL_SHARED_LIBRARIES += libdl
+endif
$$(call emugl-end-module)
endef # define gralloc_recipe
diff --git a/system/gralloc/CMakeLists.txt b/system/gralloc/CMakeLists.txt
new file mode 100644
index 0000000..22318ae
--- /dev/null
+++ b/system/gralloc/CMakeLists.txt
@@ -0,0 +1,20 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/gralloc/Android.mk" "3898852aade0f86cf9db2d73e90a5294e04aebb513e4757bf5f9ceaaeab528bb")
+set(gralloc.goldfish_src gralloc.cpp)
+android_add_shared_library(gralloc.goldfish)
+target_include_directories(gralloc.goldfish PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(gralloc.goldfish PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"gralloc_goldfish\"")
+target_compile_options(gralloc.goldfish PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers")
+target_link_libraries(gralloc.goldfish PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log GLESv2_enc _renderControl_enc GLESv1_enc OpenglCodecCommon_host)
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/gralloc/Android.mk" "3898852aade0f86cf9db2d73e90a5294e04aebb513e4757bf5f9ceaaeab528bb")
+set(gralloc.ranchu_src gralloc.cpp)
+android_add_shared_library(gralloc.ranchu)
+target_include_directories(gralloc.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(gralloc.ranchu PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"gralloc_ranchu\"")
+target_compile_options(gralloc.ranchu PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers")
+target_link_libraries(gralloc.ranchu PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log GLESv2_enc _renderControl_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/gralloc/gralloc.cpp b/system/gralloc/gralloc.cpp
index fc68f4e..48b4079 100644
--- a/system/gralloc/gralloc.cpp
+++ b/system/gralloc/gralloc.cpp
@@ -21,13 +21,21 @@
#include <errno.h>
#include <dlfcn.h>
#include <sys/mman.h>
+
+#if PLATFORM_SDK_VERSION < 28
#include "gralloc_cb.h"
+#else
+#include "../../shared/OpenglCodecCommon/gralloc_cb.h"
+#endif
+
#include "goldfish_dma.h"
#include "FormatConversions.h"
#include "HostConnection.h"
#include "ProcessPipe.h"
+#include "ThreadInfo.h"
#include "glUtils.h"
-#include <utils/CallStack.h>
+#include "qemu_pipe.h"
+
#include <cutils/log.h>
#include <cutils/properties.h>
@@ -339,6 +347,13 @@
return -EIO; \
}
+#define EXIT_GRALLOCONLY_HOST_CONNECTION \
+ if (hostCon && hostCon->isGrallocOnly()) { \
+ ALOGD("%s: exiting HostConnection (is buffer-handling thread)", \
+ __FUNCTION__); \
+ HostConnection::exit(); \
+ }
+
#if PLATFORM_SDK_VERSION < 18
// On older APIs, just define it as a value no one is going to use.
#define HAL_PIXEL_FORMAT_YCbCr_420_888 0xFFFFFFFF
@@ -665,7 +680,7 @@
}
D("gralloc_alloc format=%d, ashmem_size=%d, stride=%d, tid %d\n", format,
- ashmem_size, stride, gettid());
+ ashmem_size, stride, getCurrentThreadId());
//
// Allocate space in ashmem if needed
@@ -731,7 +746,6 @@
} else {
cb->hostHandle = rcEnc->rcCreateColorBuffer(rcEnc, w, h, allocFormat);
}
- D("Created host ColorBuffer 0x%x\n", cb->hostHandle);
}
if (!cb->hostHandle) {
@@ -740,6 +754,13 @@
delete cb;
ALOGD("%s: failed to create host cb! -EIO", __FUNCTION__);
return -EIO;
+ } else {
+ QEMU_PIPE_HANDLE refcountPipeFd = qemu_pipe_open("refcount");
+ if(qemu_pipe_valid(refcountPipeFd)) {
+ cb->setRefcountPipeFd(refcountPipeFd);
+ qemu_pipe_write(refcountPipeFd, &cb->hostHandle, 4);
+ }
+ D("Created host ColorBuffer 0x%x\n", cb->hostHandle);
}
if (isHidlGralloc) { *getOpenCountPtr(cb) = 0; }
@@ -785,11 +806,13 @@
D("%s: for buf %p ptr %p size %d\n",
__FUNCTION__, handle, cb->ashmemBase, cb->ashmemSize);
- if (cb->hostHandle) {
+ if (cb->hostHandle && !cb->hasRefcountPipe()) {
int32_t openCount = 1;
int32_t* openCountPtr = &openCount;
- if (isHidlGralloc) { openCountPtr = getOpenCountPtr(cb); }
+ if (isHidlGralloc && cb->ashmemBase) {
+ openCountPtr = getOpenCountPtr(cb);
+ }
if (*openCountPtr > 0) {
DEFINE_AND_VALIDATE_HOST_CONNECTION;
@@ -813,6 +836,9 @@
close(cb->fd);
}
+ if(qemu_pipe_valid(cb->refcount_pipe_fd)) {
+ qemu_pipe_close(cb->refcount_pipe_fd);
+ }
D("%s: done", __FUNCTION__);
// remove it from the allocated list
gralloc_device_t *grdev = (gralloc_device_t *)dev;
@@ -943,7 +969,7 @@
{
fb_device_t *fbdev = (fb_device_t *)dev;
- delete fbdev;
+ free(fbdev);
return 0;
}
@@ -973,7 +999,7 @@
D("gralloc_register_buffer(%p) w %d h %d format 0x%x framworkFormat 0x%x",
handle, cb->width, cb->height, cb->format, cb->frameworkFormat);
- if (cb->hostHandle != 0) {
+ if (cb->hostHandle != 0 && !cb->hasRefcountPipe()) {
DEFINE_AND_VALIDATE_HOST_CONNECTION;
D("Opening host ColorBuffer 0x%x\n", cb->hostHandle);
rcEnc->rcOpenColorBuffer2(rcEnc, cb->hostHandle);
@@ -1029,7 +1055,7 @@
}
- if (cb->hostHandle) {
+ if (cb->hostHandle && !cb->hasRefcountPipe()) {
D("Closing host ColorBuffer 0x%x\n", cb->hostHandle);
DEFINE_AND_VALIDATE_HOST_CONNECTION;
rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
@@ -1046,6 +1072,8 @@
}
}
}
+ EXIT_GRALLOCONLY_HOST_CONNECTION;
+
}
//
@@ -1070,6 +1098,7 @@
cb->ashmemBase = 0;
cb->mappedPid = 0;
D("%s: Unregister buffer previous mapped to pid %d", __FUNCTION__, getpid());
+ EXIT_GRALLOCONLY_HOST_CONNECTION;
}
done:
@@ -1173,7 +1202,7 @@
// host failed the color buffer sync - probably since it was already
// locked for write access. fail the lock.
ALOGE("gralloc_lock cacheFlush failed postCount=%d sw_read=%d\n",
- postCount, sw_read);
+ (int)postCount, sw_read);
return -EBUSY;
}
diff --git a/system/hwc2/Android.mk b/system/hwc2/Android.mk
new file mode 100644
index 0000000..a3bf20f
--- /dev/null
+++ b/system/hwc2/Android.mk
@@ -0,0 +1,61 @@
+#
+# Copyright 2015 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.
+#
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_VENDOR_MODULE := true
+emulator_hwcomposer_shared_libraries := \
+ liblog \
+ libutils \
+ libcutils \
+ libEGL \
+ libutils \
+ libhardware \
+ libsync \
+ libui \
+
+emulator_hwcomposer_cflags += \
+ -DLOG_TAG=\"hwc2\"
+
+emulator_hwcomposer_c_includes += \
+ 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
+
+emulator_hwcomposer_relative_path := hw
+
+emulator_hwcomposer2_src_files := \
+ EmuHWC2.cpp \
+ MiniFence.cpp
+
+include $(CLEAR_VARS)
+
+LOCAL_VENDOR_MODULE := true
+LOCAL_SHARED_LIBRARIES := $(emulator_hwcomposer_shared_libraries)
+LOCAL_SHARED_LIBRARIES += libOpenglSystemCommon lib_renderControl_enc
+LOCAL_SRC_FILES := $(emulator_hwcomposer2_src_files)
+LOCAL_C_INCLUDES := $(emulator_hwcomposer_c_includes)
+LOCAL_MODULE_RELATIVE_PATH := $(emulator_hwcomposer_relative_path)
+
+LOCAL_MODULE := hwcomposer.ranchu
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/system/hwc2/EmuHWC2.cpp b/system/hwc2/EmuHWC2.cpp
new file mode 100644
index 0000000..37466a1
--- /dev/null
+++ b/system/hwc2/EmuHWC2.cpp
@@ -0,0 +1,1336 @@
+/*
+ * 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 <log/log.h>
+#include <sync/sync.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);
+}
+
+#define DEFINE_AND_VALIDATE_HOST_CONNECTION \
+ HostConnection *hostCon = HostConnection::get(); \
+ 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();
+}
+
+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>);
+ // 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_VSYNC>(pointer);
+ hotplug(callbackData, 0, static_cast<int32_t>(Connection::Connected));
+ }
+
+ return Error::None;
+}
+
+//Gralloc Functions
+EmuHWC2::GrallocModule::GrallocModule() {
+ int ret;
+
+ ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mHw);
+ assert(ret == 0 && "Gralloc moudle not found");
+ mGralloc = reinterpret_cast<const gralloc_module_t*>(mHw);
+
+ ret = framebuffer_open(mHw, &mFbDev);
+ assert(ret == 0 && "Fail to open FrameBuffer device");
+}
+
+EmuHWC2::GrallocModule::~GrallocModule() {
+ if (mHandle != nullptr) {
+ mGralloc->unregisterBuffer(mGralloc, mHandle);
+ mAllocDev->free(mAllocDev, mHandle);
+ ALOGI("free targetCb %d", ((cb_handle_t*)(mHandle))->hostHandle);
+ }
+}
+
+uint32_t EmuHWC2::GrallocModule::getTargetCb() {
+ if (mHandle == nullptr) {
+ int ret, stride;
+ ret = gralloc_open(mHw, &mAllocDev);
+ assert(ret == 0 && "Fail to open GPU device");
+ ret = mAllocDev->alloc(mAllocDev,
+ mFbDev->width, mFbDev->height, mFbDev->format,
+ GRALLOC_USAGE_HW_COMPOSER|GRALLOC_USAGE_HW_RENDER,
+ &mHandle, &stride);
+ assert(ret == 0 && "Fail to allocate target ColorBuffer");
+ mGralloc->registerBuffer(mGralloc, mHandle);
+ ALOGI("targetCb %d", reinterpret_cast<const cb_handle_t*>(mHandle)
+ ->hostHandle);
+ }
+ return reinterpret_cast<const cb_handle_t*>(mHandle)->hostHandle;
+}
+
+// Display functions
+
+std::atomic<hwc2_display_t> EmuHWC2::Display::sNextId(0);
+
+EmuHWC2::Display::Display(EmuHWC2& device, DisplayType type)
+ : mDevice(device),
+ mId(sNextId++),
+ mName(),
+ mType(type),
+ mPowerMode(PowerMode::Off),
+ mVsyncEnabled(Vsync::Invalid),
+ mVsyncPeriod(1000*1000*1000/60), // vsync is 60 hz
+ mVsyncThread(*this),
+ mClientTarget(),
+ mChanges(),
+ mLayers(),
+ mConfigs(),
+ mActiveConfig(nullptr),
+ mColorModes(),
+ mSetColorTransform(false),
+ mStateMutex()
+ {
+ mVsyncThread.run("", HAL_PRIORITY_URGENT_DISPLAY);
+ }
+
+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 = 0;
+ 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__);
+ 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
+ if (rcEnc->hasHostCompositionV1()) {
+ uint32_t numLayer = 0;
+ for (auto layer: mLayers) {
+ if (layer->getCompositionType() == Composition::Device ||
+ layer->getCompositionType() == Composition::SolidColor) {
+ numLayer++;
+ }
+ }
+ ALOGV("present %d layers total %u layers", numLayer,
+ (uint32_t)mLayers.size());
+ if (numLayer == 0) {
+ mGralloc->getFb()->post(mGralloc->getFb(), mClientTarget.getBuffer());
+ *outRetireFence = mClientTarget.getFence();
+ return Error::None;
+ }
+
+ if (mComposeMsg == nullptr || mComposeMsg->getLayerCnt() < numLayer) {
+ mComposeMsg.reset(new ComposeMsg(numLayer));
+ }
+
+ // Handle the composition
+ ComposeDevice* p = mComposeMsg->get();
+ ComposeLayer* l = p->layer;
+ for (auto layer: mLayers) {
+ if (layer->getCompositionType() != Composition::Device &&
+ layer->getCompositionType() != Composition::SolidColor) {
+ ALOGE("%s: Unsupported composition types %d",
+ __FUNCTION__, layer->getCompositionType());
+ continue;
+ }
+ // send layer composition command to host
+ if (layer->getCompositionType() == Composition::Device) {
+ int fence = layer->getLayerBuffer().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);
+ }
+ }
+ else {
+ ALOGV("%s: aquiredFence not set for layer %u",
+ __FUNCTION__, (uint32_t)layer->getId());
+ }
+ cb_handle_t *cb =
+ (cb_handle_t *)layer->getLayerBuffer().getBuffer();
+ if (cb != nullptr) {
+ l->cbHandle = cb->hostHandle;
+ }
+ 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++;
+ }
+ p->version = 1;
+ p->targetHandle = mGralloc->getTargetCb();
+ p->numLayers = numLayer;
+
+ rcEnc->rcCompose(rcEnc,
+ sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer),
+ (void *)p);
+ // not set retireFence should be fine, because the rcCompose is a
+ // sync call, it returns until the host call eglswapbuffers
+ *outRetireFence = -1;
+ }
+ else {
+ // we set all layers Composition::Client, so do nothing.
+ mGralloc->getFb()->post(mGralloc->getFb(), 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", __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,
+ (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__);
+
+ cb_handle_t *cb =
+ (cb_handle_t *)target;
+ ALOGV("%s: display(%u) buffer handle %p cb %d, acquireFence %d", __FUNCTION__,
+ (uint32_t)mId, target, cb->hostHandle, acquireFence);
+ std::unique_lock<std::mutex> lock(mStateMutex);
+ mClientTarget.setBuffer(target);
+ mClientTarget.setFence(acquireFence);
+ return Error::None;
+}
+
+Error EmuHWC2::Display::setColorMode(int32_t intMode) {
+ ALOGVV("%s", __FUNCTION__);
+ 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", __FUNCTION__);
+ 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", __FUNCTION__);
+ 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
+ if (rcEnc->hasHostCompositionV1()) {
+ // Support Device and SolidColor, otherwise, fallback all layers
+ // to Client
+ bool fallBack = false;
+ for (auto& layer : mLayers) {
+ if (layer->getCompositionType() == Composition::Client ||
+ layer->getCompositionType() == Composition::Cursor ||
+ layer->getCompositionType() == Composition::Sideband) {
+ ALOGV("%s: layer %u CompositionType %d\n", __FUNCTION__,
+ (uint32_t)layer->getId(), layer->getCompositionType());
+ fallBack = true;
+ break;
+ }
+ }
+ if (mSetColorTransform) {
+ fallBack = true;
+ }
+ if (fallBack) {
+ for (auto& layer : mLayers) {
+ 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;
+}
+
+
+int EmuHWC2::Display::populatePrimaryConfigs() {
+ ALOGVV("%s DisplayId %u", __FUNCTION__, (uint32_t)mId);
+ std::unique_lock<std::mutex> lock(mStateMutex);
+
+ mGralloc.reset(new GrallocModule());
+ auto newConfig = std::make_shared<Config>(*this);
+ // vsync is 60 hz;
+ newConfig->setAttribute(Attribute::VsyncPeriod, mVsyncPeriod);
+ newConfig->setAttribute(Attribute::Width, mGralloc->getFb()->width);
+ newConfig->setAttribute(Attribute::Height, mGralloc->getFb()->height);
+ newConfig->setAttribute(Attribute::DpiX, mGralloc->getFb()->xdpi*1000);
+ newConfig->setAttribute(Attribute::DpiY, mGralloc->getFb()->ydpi*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);
+
+ return 0;
+}
+
+
+// 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;
+
+ while (true) {
+ int err = nanosleep(&wait_time, NULL);
+ if (err == -1) {
+ if (errno == EINTR) {
+ break;
+ }
+ ALOGE("%s: error in vsync thread: %s", __FUNCTION__, strerror(errno));
+ }
+
+ std::unique_lock<std::mutex> lock(mDisplay.mStateMutex);
+ vsyncEnabled = (mDisplay.mVsyncEnabled == Vsync::Enable);
+ lock.unlock();
+
+ if (!vsyncEnabled) {
+ continue;
+ }
+
+ if (clock_gettime(CLOCK_MONOTONIC, &rt) == -1) {
+ ALOGE("%s: error in vsync thread clock_gettime: %s",
+ __FUNCTION__, strerror(errno));
+ }
+
+ int64_t timestamp = int64_t(rt.tv_sec) * 1e9 + rt.tv_nsec;
+
+ 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, timestamp);
+ }
+
+ 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) {
+ 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", __FUNCTION__);
+ if (mCompositionType != Composition::Cursor) {
+ return Error::BadLayer;
+ }
+ //TODO
+ return Error::None;
+}
+
+Error EmuHWC2::Layer::setSurfaceDamage(hwc_region_t /*damage*/) {
+ // Emulator redraw whole layer per frame, so ignore this.
+ 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", __FUNCTION__);
+ mColor = color;
+ return Error::None;
+}
+
+Error EmuHWC2::Layer::setCompositionType(int32_t type) {
+ ALOGVV("%s", __FUNCTION__);
+ mCompositionType = static_cast<Composition>(type);
+ return Error::None;
+}
+
+Error EmuHWC2::Layer::setDataspace(int32_t) {
+ return Error::None;
+}
+
+Error EmuHWC2::Layer::setDisplayFrame(hwc_rect_t frame) {
+ mDisplayFrame = frame;
+ return Error::None;
+}
+
+Error EmuHWC2::Layer::setPlaneAlpha(float alpha) {
+ mPlaneAlpha = alpha;
+ return Error::None;
+}
+
+Error EmuHWC2::Layer::setSidebandStream(const native_handle_t* stream) {
+ mSidebandStream = stream;
+ return Error::None;
+}
+
+Error EmuHWC2::Layer::setSourceCrop(hwc_frect_t crop) {
+ mSourceCrop = crop;
+ return Error::None;
+}
+
+Error EmuHWC2::Layer::setTransform(int32_t transform) {
+ 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 %d", __FUNCTION__, z);
+ mZ = z;
+ return Error::None;
+}
+
+// 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);
+ ret = display->populatePrimaryConfigs();
+ if (ret != 0) {
+ return ret;
+ }
+ mDisplays.emplace(display->getId(), std::move(display));
+ return ret;
+}
+
+EmuHWC2::Display* EmuHWC2::getDisplay(hwc2_display_t id) {
+ auto display = mDisplays.find(id);
+ if (display == mDisplays.end()) {
+ 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) {
+ ALOGV("%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;
+ }
+
+ 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
new file mode 100644
index 0000000..0d768dd
--- /dev/null
+++ b/system/hwc2/EmuHWC2.h
@@ -0,0 +1,448 @@
+/*
+ * 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 <atomic>
+#include <map>
+#include <mutex>
+#include <vector>
+#include <unordered_set>
+#include <unordered_map>
+#include <set>
+
+#include "gralloc_cb.h"
+#include "MiniFence.h"
+#include "HostConnection.h"
+
+namespace android {
+
+class EmuHWC2 : public hwc2_device_t {
+public:
+ EmuHWC2();
+ int populatePrimary();
+
+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);
+ };
+
+ // 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), mFence(MiniFence::NO_FENCE) {}
+
+ void setBuffer(buffer_handle_t buffer) { mBuffer = buffer; }
+ void setFence(int fenceFd) { mFence = new MiniFence(fenceFd); }
+
+ buffer_handle_t getBuffer() const { return mBuffer; }
+ int getFence() const { return mFence->dup(); }
+
+ private:
+ buffer_handle_t mBuffer;
+ sp<MiniFence> mFence;
+ };
+
+ class GrallocModule {
+ public:
+ GrallocModule();
+ ~GrallocModule();
+ framebuffer_device_t* getFb() { return mFbDev; }
+ uint32_t getTargetCb();
+ private:
+ const hw_module_t* mHw = nullptr;
+ const gralloc_module_t* mGralloc = nullptr;
+ alloc_device_t* mAllocDev = nullptr;
+ framebuffer_device_t* mFbDev = nullptr;
+ buffer_handle_t mHandle = nullptr;
+ };
+
+ 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;
+
+ 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 Display {
+ public:
+ Display(EmuHWC2& device, HWC2::DisplayType type);
+ 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);
+
+ // Read configs from PRIMARY Display
+ int populatePrimaryConfigs();
+
+ private:
+ 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;
+ const hwc2_display_t mId;
+ 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<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<GrallocModule> mGralloc;
+ std::unique_ptr<ComposeMsg> mComposeMsg;
+ };
+
+ 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);
+
+ 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;
+
+ std::unordered_map<hwc2_display_t, std::shared_ptr<Display>> mDisplays;
+ std::unordered_map<hwc2_layer_t, std::shared_ptr<Layer>> mLayers;
+
+};
+
+}
+#endif
diff --git a/system/hwc2/MiniFence.cpp b/system/hwc2/MiniFence.cpp
new file mode 100644
index 0000000..ecfb063
--- /dev/null
+++ b/system/hwc2/MiniFence.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 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 "MiniFence.h"
+
+#include <unistd.h>
+
+namespace android {
+
+const sp<MiniFence> MiniFence::NO_FENCE = sp<MiniFence>(new MiniFence);
+
+MiniFence::MiniFence() :
+ mFenceFd(-1) {
+}
+
+MiniFence::MiniFence(int fenceFd) :
+ mFenceFd(fenceFd) {
+}
+
+MiniFence::~MiniFence() {
+ if (mFenceFd != -1) {
+ close(mFenceFd);
+ }
+}
+
+int MiniFence::dup() const {
+ return ::dup(mFenceFd);
+}
+}
diff --git a/system/hwc2/MiniFence.h b/system/hwc2/MiniFence.h
new file mode 100644
index 0000000..31c9536
--- /dev/null
+++ b/system/hwc2/MiniFence.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2017 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 EMU_HWC2_MINIFENCE_H
+#define EMU_HWC2_MINIFENCE_H
+
+#include <utils/RefBase.h>
+
+namespace android {
+
+/* MiniFence is a minimal re-implementation of Fence from libui. It exists to
+ * avoid linking the HWC2on1Adapter to libui and satisfy Treble requirements.
+ */
+class MiniFence : public LightRefBase<MiniFence> {
+public:
+ static const sp<MiniFence> NO_FENCE;
+
+ // Construct a new MiniFence object with an invalid file descriptor.
+ MiniFence();
+
+ // Construct a new MiniFence object to manage a given fence file descriptor.
+ // When the new MiniFence object is destructed the file descriptor will be
+ // closed.
+ explicit MiniFence(int fenceFd);
+
+ // Not copyable or movable.
+ MiniFence(const MiniFence& rhs) = delete;
+ MiniFence& operator=(const MiniFence& rhs) = delete;
+ MiniFence(MiniFence&& rhs) = delete;
+ MiniFence& operator=(MiniFence&& rhs) = delete;
+
+ // Return a duplicate of the fence file descriptor. The caller is
+ // responsible for closing the returned file descriptor. On error, -1 will
+ // be returned and errno will indicate the problem.
+ int dup() const;
+
+private:
+ // Only allow instantiation using ref counting.
+ friend class LightRefBase<MiniFence>;
+ ~MiniFence();
+
+ int mFenceFd;
+
+};
+}
+#endif //EMU_HWC2_MINIFENCE_H
diff --git a/system/renderControl_enc/Android.mk b/system/renderControl_enc/Android.mk
index 5792440..fa90bcb 100644
--- a/system/renderControl_enc/Android.mk
+++ b/system/renderControl_enc/Android.mk
@@ -8,5 +8,5 @@
renderControl_entry.cpp
$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
-$(call emugl-import,libOpenglCodecCommon)
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
$(call emugl-end-module)
diff --git a/system/renderControl_enc/CMakeLists.txt b/system/renderControl_enc/CMakeLists.txt
new file mode 100644
index 0000000..40280fd
--- /dev/null
+++ b/system/renderControl_enc/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc/Android.mk" "f314acdb6134d3e545889739e6e9bf8837177ce2f3318106394c7656c5d8b992")
+set(_renderControl_enc_src renderControl_client_context.cpp renderControl_enc.cpp renderControl_entry.cpp)
+android_add_shared_library(_renderControl_enc)
+target_include_directories(_renderControl_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(_renderControl_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN")
+target_compile_options(_renderControl_enc PRIVATE "-fvisibility=default")
+target_link_libraries(_renderControl_enc PRIVATE OpenglCodecCommon_host cutils utils log android-emu-shared)
\ No newline at end of file
diff --git a/system/renderControl_enc/renderControl_client_context.cpp b/system/renderControl_enc/renderControl_client_context.cpp
index 4a86244..fb5ead1 100644
--- a/system/renderControl_enc/renderControl_client_context.cpp
+++ b/system/renderControl_enc/renderControl_client_context.cpp
@@ -47,6 +47,7 @@
rcUpdateColorBufferDMA = (rcUpdateColorBufferDMA_client_proc_t) getProc("rcUpdateColorBufferDMA", userData);
rcCreateColorBufferDMA = (rcCreateColorBufferDMA_client_proc_t) getProc("rcCreateColorBufferDMA", userData);
rcWaitSyncKHR = (rcWaitSyncKHR_client_proc_t) getProc("rcWaitSyncKHR", userData);
+ rcCompose = (rcCompose_client_proc_t) getProc("rcCompose", userData);
return 0;
}
diff --git a/system/renderControl_enc/renderControl_client_context.h b/system/renderControl_enc/renderControl_client_context.h
index 1e5594b..5d3878c 100644
--- a/system/renderControl_enc/renderControl_client_context.h
+++ b/system/renderControl_enc/renderControl_client_context.h
@@ -47,6 +47,7 @@
rcUpdateColorBufferDMA_client_proc_t rcUpdateColorBufferDMA;
rcCreateColorBufferDMA_client_proc_t rcCreateColorBufferDMA;
rcWaitSyncKHR_client_proc_t rcWaitSyncKHR;
+ rcCompose_client_proc_t rcCompose;
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 3f1e5bb..24708dd 100644
--- a/system/renderControl_enc/renderControl_client_proc.h
+++ b/system/renderControl_enc/renderControl_client_proc.h
@@ -46,6 +46,7 @@
typedef int (renderControl_APIENTRY *rcUpdateColorBufferDMA_client_proc_t) (void * ctx, uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*, uint32_t);
typedef uint32_t (renderControl_APIENTRY *rcCreateColorBufferDMA_client_proc_t) (void * ctx, uint32_t, uint32_t, GLenum, int);
typedef void (renderControl_APIENTRY *rcWaitSyncKHR_client_proc_t) (void * ctx, uint64_t, EGLint);
+typedef GLint (renderControl_APIENTRY *rcCompose_client_proc_t) (void * ctx, uint32_t, void*);
#endif
diff --git a/system/renderControl_enc/renderControl_enc.cpp b/system/renderControl_enc/renderControl_enc.cpp
index e22d7c0..905b6a9 100644
--- a/system/renderControl_enc/renderControl_enc.cpp
+++ b/system/renderControl_enc/renderControl_enc.cpp
@@ -8,6 +8,8 @@
#include "renderControl_enc.h"
+#include <vector>
+
#include <stdio.h>
namespace {
@@ -1391,6 +1393,49 @@
}
+GLint rcCompose_enc(void *self , uint32_t bufferSize, void* buffer)
+{
+
+ renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_buffer = bufferSize;
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_rcCompose;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &bufferSize, 4); ptr += 4;
+ *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
+ memcpy(ptr, buffer, __size_buffer);ptr += __size_buffer;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ GLint 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("rcCompose: 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)
@@ -1435,5 +1480,6 @@
this->rcUpdateColorBufferDMA = &rcUpdateColorBufferDMA_enc;
this->rcCreateColorBufferDMA = &rcCreateColorBufferDMA_enc;
this->rcWaitSyncKHR = &rcWaitSyncKHR_enc;
+ this->rcCompose = &rcCompose_enc;
}
diff --git a/system/renderControl_enc/renderControl_entry.cpp b/system/renderControl_enc/renderControl_entry.cpp
index 9a47dd3..4296940 100644
--- a/system/renderControl_enc/renderControl_entry.cpp
+++ b/system/renderControl_enc/renderControl_entry.cpp
@@ -42,6 +42,7 @@
int rcUpdateColorBufferDMA(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels, uint32_t pixels_size);
uint32_t rcCreateColorBufferDMA(uint32_t width, uint32_t height, GLenum internalFormat, int frameworkFormat);
void rcWaitSyncKHR(uint64_t sync, EGLint flags);
+ GLint rcCompose(uint32_t bufferSize, void* buffer);
};
#ifndef GET_CONTEXT
@@ -272,3 +273,9 @@
ctx->rcWaitSyncKHR(ctx, sync, flags);
}
+GLint rcCompose(uint32_t bufferSize, void* buffer)
+{
+ GET_CONTEXT;
+ return ctx->rcCompose(ctx, bufferSize, buffer);
+}
+
diff --git a/system/renderControl_enc/renderControl_ftable.h b/system/renderControl_enc/renderControl_ftable.h
index 7bfc7c5..ab75bb0 100644
--- a/system/renderControl_enc/renderControl_ftable.h
+++ b/system/renderControl_enc/renderControl_ftable.h
@@ -45,6 +45,7 @@
{"rcUpdateColorBufferDMA", (void*)rcUpdateColorBufferDMA},
{"rcCreateColorBufferDMA", (void*)rcCreateColorBufferDMA},
{"rcWaitSyncKHR", (void*)rcWaitSyncKHR},
+ {"rcCompose", (void*)rcCompose},
};
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 146164f..100faaa 100644
--- a/system/renderControl_enc/renderControl_opcodes.h
+++ b/system/renderControl_enc/renderControl_opcodes.h
@@ -40,7 +40,8 @@
#define OP_rcUpdateColorBufferDMA 10034
#define OP_rcCreateColorBufferDMA 10035
#define OP_rcWaitSyncKHR 10036
-#define OP_last 10037
+#define OP_rcCompose 10037
+#define OP_last 10038
#endif
diff --git a/system/vulkan/Android.mk b/system/vulkan/Android.mk
new file mode 100644
index 0000000..88118c2
--- /dev/null
+++ b/system/vulkan/Android.mk
@@ -0,0 +1,39 @@
+LOCAL_PATH := $(call my-dir)
+
+$(call emugl-begin-shared-library,vulkan.ranchu)
+$(call emugl-set-shared-library-subpath,hw)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
+$(call emugl-import,libOpenglSystemCommon libvulkan_enc lib_renderControl_enc)
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX))
+
+# Vulkan include dir
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+LOCAL_C_INCLUDES += $(HOST_EMUGL_PATH)/host/include
+
+endif
+
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+# Only import androidemu if not building for host.
+# if building for host, we already import android-emu.
+$(call emugl-import,libandroidemu)
+
+LOCAL_HEADER_LIBRARIES += \
+ vulkan_headers \
+
+endif
+
+LOCAL_CFLAGS += \
+ -DLOG_TAG=\"goldfish_vulkan\" \
+ -Wno-missing-field-initializers \
+ -fvisibility=hidden \
+ -fstrict-aliasing \
+ -DVK_USE_PLATFORM_ANDROID_KHR \
+ -DVK_NO_PROTOTYPES \
+
+LOCAL_SRC_FILES := \
+ func_table.cpp \
+ goldfish_vulkan.cpp \
+
+$(call emugl-end-module)
diff --git a/system/vulkan/CMakeLists.txt b/system/vulkan/CMakeLists.txt
new file mode 100644
index 0000000..e7fd9bb
--- /dev/null
+++ b/system/vulkan/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan/Android.mk" "dbe5f184561a1505d6ed26216fe645508b64bf2f3800f67946428077045c8166")
+set(vulkan.ranchu_src func_table.cpp goldfish_vulkan.cpp)
+android_add_shared_library(vulkan.ranchu)
+target_include_directories(vulkan.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/vulkan ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include)
+target_compile_definitions(vulkan.ranchu PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES")
+target_compile_options(vulkan.ranchu PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers" "-fvisibility=hidden" "-fstrict-aliasing")
+target_link_libraries(vulkan.ranchu PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui cutils utils log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host)
\ No newline at end of file
diff --git a/system/vulkan/func_table.cpp b/system/vulkan/func_table.cpp
new file mode 100644
index 0000000..ea87560
--- /dev/null
+++ b/system/vulkan/func_table.cpp
@@ -0,0 +1,4721 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module func_table
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "func_table.h"
+
+
+#include "VkEncoder.h"
+#include "HostConnection.h"
+
+#include "goldfish_vk_private_defs.h"
+
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+static VkResult entry_vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateInstance_VkResult_return = (VkResult)0;
+ vkCreateInstance_VkResult_return = vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance);
+ return vkCreateInstance_VkResult_return;
+}
+static void entry_vkDestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyInstance(instance, pAllocator);
+}
+static VkResult entry_vkEnumeratePhysicalDevices(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
+ vkEnumeratePhysicalDevices_VkResult_return = vkEnc->vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+ return vkEnumeratePhysicalDevices_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceImageFormatProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+ return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+}
+static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ vkGetInstanceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetInstanceProcAddr(instance, pName);
+ return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
+}
+static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(
+ VkDevice device,
+ const char* pName)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ vkGetDeviceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetDeviceProcAddr(device, pName);
+ return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
+}
+static VkResult entry_vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDevice_VkResult_return = (VkResult)0;
+ vkCreateDevice_VkResult_return = vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+ return vkCreateDevice_VkResult_return;
+}
+static void entry_vkDestroyDevice(
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDevice(device, pAllocator);
+}
+static VkResult entry_vkEnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
+ vkEnumerateInstanceExtensionProperties_VkResult_return = vkEnc->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+ return vkEnumerateInstanceExtensionProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
+ vkEnumerateDeviceExtensionProperties_VkResult_return = vkEnc->vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+ return vkEnumerateDeviceExtensionProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateInstanceLayerProperties(
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+ vkEnumerateInstanceLayerProperties_VkResult_return = vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+ return vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
+ vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+ return vkEnumerateDeviceLayerProperties_VkResult_return;
+}
+static void entry_vkGetDeviceQueue(
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+}
+static VkResult entry_vkQueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
+ vkQueueSubmit_VkResult_return = vkEnc->vkQueueSubmit(queue, submitCount, pSubmits, fence);
+ return vkQueueSubmit_VkResult_return;
+}
+static VkResult entry_vkQueueWaitIdle(
+ VkQueue queue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
+ vkQueueWaitIdle_VkResult_return = vkEnc->vkQueueWaitIdle(queue);
+ return vkQueueWaitIdle_VkResult_return;
+}
+static VkResult entry_vkDeviceWaitIdle(
+ VkDevice device)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
+ vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device);
+ return vkDeviceWaitIdle_VkResult_return;
+}
+static VkResult entry_vkAllocateMemory(
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
+ vkAllocateMemory_VkResult_return = vkEnc->vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+ return vkAllocateMemory_VkResult_return;
+}
+static void entry_vkFreeMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkFreeMemory(device, memory, pAllocator);
+}
+static VkResult entry_vkMapMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkMapMemory_VkResult_return = (VkResult)0;
+ vkMapMemory_VkResult_return = vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData);
+ return vkMapMemory_VkResult_return;
+}
+static void entry_vkUnmapMemory(
+ VkDevice device,
+ VkDeviceMemory memory)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkUnmapMemory(device, memory);
+}
+static VkResult entry_vkFlushMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
+ vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ return vkFlushMappedMemoryRanges_VkResult_return;
+}
+static VkResult entry_vkInvalidateMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
+ vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ return vkInvalidateMappedMemoryRanges_VkResult_return;
+}
+static void entry_vkGetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+}
+static VkResult entry_vkBindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
+ vkBindBufferMemory_VkResult_return = vkEnc->vkBindBufferMemory(device, buffer, memory, memoryOffset);
+ return vkBindBufferMemory_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory(
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
+ vkBindImageMemory_VkResult_return = vkEnc->vkBindImageMemory(device, image, memory, memoryOffset);
+ return vkBindImageMemory_VkResult_return;
+}
+static void entry_vkGetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+}
+static void entry_vkGetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+}
+static VkResult entry_vkQueueBindSparse(
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
+ vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+ return vkQueueBindSparse_VkResult_return;
+}
+static VkResult entry_vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateFence_VkResult_return = (VkResult)0;
+ vkCreateFence_VkResult_return = vkEnc->vkCreateFence(device, pCreateInfo, pAllocator, pFence);
+ return vkCreateFence_VkResult_return;
+}
+static void entry_vkDestroyFence(
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyFence(device, fence, pAllocator);
+}
+static VkResult entry_vkResetFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetFences_VkResult_return = (VkResult)0;
+ vkResetFences_VkResult_return = vkEnc->vkResetFences(device, fenceCount, pFences);
+ return vkResetFences_VkResult_return;
+}
+static VkResult entry_vkGetFenceStatus(
+ VkDevice device,
+ VkFence fence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
+ vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence);
+ return vkGetFenceStatus_VkResult_return;
+}
+static VkResult entry_vkWaitForFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkWaitForFences_VkResult_return = (VkResult)0;
+ vkWaitForFences_VkResult_return = vkEnc->vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ return vkWaitForFences_VkResult_return;
+}
+static VkResult entry_vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
+ vkCreateSemaphore_VkResult_return = vkEnc->vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+ return vkCreateSemaphore_VkResult_return;
+}
+static void entry_vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySemaphore(device, semaphore, pAllocator);
+}
+static VkResult entry_vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateEvent_VkResult_return = (VkResult)0;
+ vkCreateEvent_VkResult_return = vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
+ return vkCreateEvent_VkResult_return;
+}
+static void entry_vkDestroyEvent(
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyEvent(device, event, pAllocator);
+}
+static VkResult entry_vkGetEventStatus(
+ VkDevice device,
+ VkEvent event)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
+ vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event);
+ return vkGetEventStatus_VkResult_return;
+}
+static VkResult entry_vkSetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkSetEvent_VkResult_return = (VkResult)0;
+ vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event);
+ return vkSetEvent_VkResult_return;
+}
+static VkResult entry_vkResetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetEvent_VkResult_return = (VkResult)0;
+ vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event);
+ return vkResetEvent_VkResult_return;
+}
+static VkResult entry_vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
+ vkCreateQueryPool_VkResult_return = vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+ return vkCreateQueryPool_VkResult_return;
+}
+static void entry_vkDestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator);
+}
+static VkResult entry_vkGetQueryPoolResults(
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
+ vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+ return vkGetQueryPoolResults_VkResult_return;
+}
+static VkResult entry_vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
+ vkCreateBuffer_VkResult_return = vkEnc->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ return vkCreateBuffer_VkResult_return;
+}
+static void entry_vkDestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyBuffer(device, buffer, pAllocator);
+}
+static VkResult entry_vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
+ vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
+ return vkCreateBufferView_VkResult_return;
+}
+static void entry_vkDestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyBufferView(device, bufferView, pAllocator);
+}
+static VkResult entry_vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateImage_VkResult_return = (VkResult)0;
+ vkCreateImage_VkResult_return = vkEnc->vkCreateImage(device, pCreateInfo, pAllocator, pImage);
+ return vkCreateImage_VkResult_return;
+}
+static void entry_vkDestroyImage(
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyImage(device, image, pAllocator);
+}
+static void entry_vkGetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
+}
+static VkResult entry_vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateImageView_VkResult_return = (VkResult)0;
+ vkCreateImageView_VkResult_return = vkEnc->vkCreateImageView(device, pCreateInfo, pAllocator, pView);
+ return vkCreateImageView_VkResult_return;
+}
+static void entry_vkDestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyImageView(device, imageView, pAllocator);
+}
+static VkResult entry_vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
+ vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+ return vkCreateShaderModule_VkResult_return;
+}
+static void entry_vkDestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator);
+}
+static VkResult entry_vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
+ vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+ return vkCreatePipelineCache_VkResult_return;
+}
+static void entry_vkDestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator);
+}
+static VkResult entry_vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
+ vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+ return vkGetPipelineCacheData_VkResult_return;
+}
+static VkResult entry_vkMergePipelineCaches(
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
+ vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+ return vkMergePipelineCaches_VkResult_return;
+}
+static VkResult entry_vkCreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
+ vkCreateGraphicsPipelines_VkResult_return = vkEnc->vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ return vkCreateGraphicsPipelines_VkResult_return;
+}
+static VkResult entry_vkCreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
+ vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ return vkCreateComputePipelines_VkResult_return;
+}
+static void entry_vkDestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyPipeline(device, pipeline, pAllocator);
+}
+static VkResult entry_vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
+ vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+ return vkCreatePipelineLayout_VkResult_return;
+}
+static void entry_vkDestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
+}
+static VkResult entry_vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSampler_VkResult_return = (VkResult)0;
+ vkCreateSampler_VkResult_return = vkEnc->vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
+ return vkCreateSampler_VkResult_return;
+}
+static void entry_vkDestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySampler(device, sampler, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
+ vkCreateDescriptorSetLayout_VkResult_return = vkEnc->vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+ return vkCreateDescriptorSetLayout_VkResult_return;
+}
+static void entry_vkDestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
+ vkCreateDescriptorPool_VkResult_return = vkEnc->vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+ return vkCreateDescriptorPool_VkResult_return;
+}
+static void entry_vkDestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
+}
+static VkResult entry_vkResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
+ vkResetDescriptorPool_VkResult_return = vkEnc->vkResetDescriptorPool(device, descriptorPool, flags);
+ return vkResetDescriptorPool_VkResult_return;
+}
+static VkResult entry_vkAllocateDescriptorSets(
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
+ vkAllocateDescriptorSets_VkResult_return = vkEnc->vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+ return vkAllocateDescriptorSets_VkResult_return;
+}
+static VkResult entry_vkFreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
+ vkFreeDescriptorSets_VkResult_return = vkEnc->vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+ return vkFreeDescriptorSets_VkResult_return;
+}
+static void entry_vkUpdateDescriptorSets(
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+}
+static VkResult entry_vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
+ vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+ return vkCreateFramebuffer_VkResult_return;
+}
+static void entry_vkDestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator);
+}
+static VkResult entry_vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
+ vkCreateRenderPass_VkResult_return = vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+ return vkCreateRenderPass_VkResult_return;
+}
+static void entry_vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator);
+}
+static void entry_vkGetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity);
+}
+static VkResult entry_vkCreateCommandPool(
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
+ vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+ return vkCreateCommandPool_VkResult_return;
+}
+static void entry_vkDestroyCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator);
+}
+static VkResult entry_vkResetCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
+ vkResetCommandPool_VkResult_return = vkEnc->vkResetCommandPool(device, commandPool, flags);
+ return vkResetCommandPool_VkResult_return;
+}
+static VkResult entry_vkAllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
+ vkAllocateCommandBuffers_VkResult_return = vkEnc->vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+ return vkAllocateCommandBuffers_VkResult_return;
+}
+static void entry_vkFreeCommandBuffers(
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+}
+static VkResult entry_vkBeginCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
+ vkBeginCommandBuffer_VkResult_return = vkEnc->vkBeginCommandBuffer(commandBuffer, pBeginInfo);
+ return vkBeginCommandBuffer_VkResult_return;
+}
+static VkResult entry_vkEndCommandBuffer(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
+ vkEndCommandBuffer_VkResult_return = vkEnc->vkEndCommandBuffer(commandBuffer);
+ return vkEndCommandBuffer_VkResult_return;
+}
+static VkResult entry_vkResetCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
+ vkResetCommandBuffer_VkResult_return = vkEnc->vkResetCommandBuffer(commandBuffer, flags);
+ return vkResetCommandBuffer_VkResult_return;
+}
+static void entry_vkCmdBindPipeline(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+}
+static void entry_vkCmdSetViewport(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport* pViewports)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+}
+static void entry_vkCmdSetScissor(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+}
+static void entry_vkCmdSetLineWidth(
+ VkCommandBuffer commandBuffer,
+ float lineWidth)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth);
+}
+static void entry_vkCmdSetDepthBias(
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+}
+static void entry_vkCmdSetBlendConstants(
+ VkCommandBuffer commandBuffer,
+ const float blendConstants)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants);
+}
+static void entry_vkCmdSetDepthBounds(
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+}
+static void entry_vkCmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+}
+static void entry_vkCmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+}
+static void entry_vkCmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference);
+}
+static void entry_vkCmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+static void entry_vkCmdBindIndexBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+}
+static void entry_vkCmdBindVertexBuffers(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+}
+static void entry_vkCmdDraw(
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}
+static void entry_vkCmdDrawIndexed(
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+}
+static void entry_vkCmdDrawIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+static void entry_vkCmdDispatch(
+ VkCommandBuffer commandBuffer,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
+}
+static void entry_vkCmdDispatchIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset);
+}
+static void entry_vkCmdCopyBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+}
+static void entry_vkCmdCopyImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdBlitImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+}
+static void entry_vkCmdCopyBufferToImage(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdCopyImageToBuffer(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+}
+static void entry_vkCmdUpdateBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+}
+static void entry_vkCmdFillBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+}
+static void entry_vkCmdClearColorImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+}
+static void entry_vkCmdClearDepthStencilImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+}
+static void entry_vkCmdClearAttachments(
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+}
+static void entry_vkCmdResolveImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdSetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask);
+}
+static void entry_vkCmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask);
+}
+static void entry_vkCmdWaitEvents(
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+static void entry_vkCmdPipelineBarrier(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+static void entry_vkCmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
+}
+static void entry_vkCmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query);
+}
+static void entry_vkCmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+}
+static void entry_vkCmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+}
+static void entry_vkCmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+}
+static void entry_vkCmdPushConstants(
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+}
+static void entry_vkCmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+}
+static void entry_vkCmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdNextSubpass(commandBuffer, contents);
+}
+static void entry_vkCmdEndRenderPass(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndRenderPass(commandBuffer);
+}
+static void entry_vkCmdExecuteCommands(
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
+}
+#endif
+#ifdef VK_VERSION_1_1
+static VkResult entry_vkEnumerateInstanceVersion(
+ uint32_t* pApiVersion)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+ vkEnumerateInstanceVersion_VkResult_return = vkEnc->vkEnumerateInstanceVersion(pApiVersion);
+ return vkEnumerateInstanceVersion_VkResult_return;
+}
+static VkResult entry_vkBindBufferMemory2(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
+ vkBindBufferMemory2_VkResult_return = vkEnc->vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
+ return vkBindBufferMemory2_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory2(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
+ vkBindImageMemory2_VkResult_return = vkEnc->vkBindImageMemory2(device, bindInfoCount, pBindInfos);
+ return vkBindImageMemory2_VkResult_return;
+}
+static void entry_vkGetDeviceGroupPeerMemoryFeatures(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
+static void entry_vkCmdSetDeviceMask(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask);
+}
+static void entry_vkCmdDispatchBase(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+}
+static VkResult entry_vkEnumeratePhysicalDeviceGroups(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
+ vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+ return vkEnumeratePhysicalDeviceGroups_VkResult_return;
+}
+static void entry_vkGetImageMemoryRequirements2(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetBufferMemoryRequirements2(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements2(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+static void entry_vkGetPhysicalDeviceFeatures2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+}
+static void entry_vkTrimCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkTrimCommandPool(device, commandPool, flags);
+}
+static void entry_vkGetDeviceQueue2(
+ VkDevice device,
+ const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue);
+}
+static VkResult entry_vkCreateSamplerYcbcrConversion(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
+ vkCreateSamplerYcbcrConversion_VkResult_return = vkEnc->vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
+ return vkCreateSamplerYcbcrConversion_VkResult_return;
+}
+static void entry_vkDestroySamplerYcbcrConversion(
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorUpdateTemplate(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+ vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+ return vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
+static void entry_vkDestroyDescriptorUpdateTemplate(
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
+}
+static void entry_vkUpdateDescriptorSetWithTemplate(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
+static void entry_vkGetPhysicalDeviceExternalBufferProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+static void entry_vkGetPhysicalDeviceExternalFenceProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+}
+static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
+static void entry_vkGetDescriptorSetLayoutSupport(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+}
+#endif
+#ifdef VK_KHR_surface
+static void entry_vkDestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySurfaceKHR(instance, surface, pAllocator);
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+ return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+ return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+ return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+ return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_swapchain
+static VkResult entry_vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+ vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+ return vkCreateSwapchainKHR_VkResult_return;
+}
+static void entry_vkDestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator);
+}
+static VkResult entry_vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+ vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+ return vkGetSwapchainImagesKHR_VkResult_return;
+}
+static VkResult entry_vkAcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+ vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+ return vkAcquireNextImageKHR_VkResult_return;
+}
+static VkResult entry_vkQueuePresentKHR(
+ VkQueue queue,
+ const VkPresentInfoKHR* pPresentInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
+ vkQueuePresentKHR_VkResult_return = vkEnc->vkQueuePresentKHR(queue, pPresentInfo);
+ return vkQueuePresentKHR_VkResult_return;
+}
+static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR(
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+ vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
+ return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHR* pModes)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
+ return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
+ return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
+}
+static VkResult entry_vkAcquireNextImage2KHR(
+ VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+ vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
+ return vkAcquireNextImage2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display
+static VkResult entry_vkGetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
+ return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
+ return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
+ vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
+ return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
+ return vkGetDisplayModePropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
+ vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
+ return vkCreateDisplayModeKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
+ vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
+ return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkCreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display_swapchain
+static VkResult entry_vkCreateSharedSwapchainsKHR(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+ vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+ return vkCreateSharedSwapchainsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_xlib_surface
+static VkResult entry_vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateXlibSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
+ return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_xcb_surface
+static VkResult entry_vkCreateXcbSurfaceKHR(
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateXcbSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
+ return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_wayland_surface
+static VkResult entry_vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateWaylandSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ wl_display* display)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
+ return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_mir_surface
+static VkResult entry_vkCreateMirSurfaceKHR(
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateMirSurfaceKHR_VkResult_return = vkEnc->vkCreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateMirSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceMirPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection);
+ return vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_android_surface
+static VkResult entry_vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateAndroidSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_surface
+static VkResult entry_vkCreateWin32SurfaceKHR(
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateWin32SurfaceKHR_VkResult_return = vkEnc->vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateWin32SurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
+ return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+static void entry_vkGetPhysicalDeviceFeatures2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+}
+#endif
+#ifdef VK_KHR_device_group
+static void entry_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
+static void entry_vkCmdSetDeviceMaskKHR(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
+}
+static void entry_vkCmdDispatchBaseKHR(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+}
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+static void entry_vkTrimCommandPoolKHR(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags);
+}
+#endif
+#ifdef VK_KHR_device_group_creation
+static VkResult entry_vkEnumeratePhysicalDeviceGroupsKHR(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
+ vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+ return vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+static VkResult entry_vkGetMemoryWin32HandleKHR(
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkGetMemoryWin32HandleKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+ return vkGetMemoryWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetMemoryWin32HandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
+ return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_fd
+static VkResult entry_vkGetMemoryFdKHR(
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+ vkGetMemoryFdKHR_VkResult_return = vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd);
+ return vkGetMemoryFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetMemoryFdPropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
+ return vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+static VkResult entry_vkImportSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
+ return vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+ return vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+static VkResult entry_vkImportSemaphoreFdKHR(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ vkImportSemaphoreFdKHR_VkResult_return = vkEnc->vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
+ return vkImportSemaphoreFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetSemaphoreFdKHR(
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ vkGetSemaphoreFdKHR_VkResult_return = vkEnc->vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd);
+ return vkGetSemaphoreFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_push_descriptor
+static void entry_vkCmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
+}
+static void entry_vkCmdPushDescriptorSetWithTemplateKHR(
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
+}
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+static VkResult entry_vkCreateDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+ vkCreateDescriptorUpdateTemplateKHR_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+ return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
+static void entry_vkDestroyDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
+}
+static void entry_vkUpdateDescriptorSetWithTemplateKHR(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
+#endif
+#ifdef VK_KHR_create_renderpass2
+static VkResult entry_vkCreateRenderPass2KHR(
+ VkDevice device,
+ const VkRenderPassCreateInfo2KHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+ vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
+ return vkCreateRenderPass2KHR_VkResult_return;
+}
+static void entry_vkCmdBeginRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+}
+static void entry_vkCmdNextSubpass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+}
+static void entry_vkCmdEndRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
+}
+#endif
+#ifdef VK_KHR_shared_presentable_image
+static VkResult entry_vkGetSwapchainStatusKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+ vkGetSwapchainStatusKHR_VkResult_return = vkEnc->vkGetSwapchainStatusKHR(device, swapchain);
+ return vkGetSwapchainStatusKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+}
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+static VkResult entry_vkImportFenceWin32HandleKHR(
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkImportFenceWin32HandleKHR_VkResult_return = vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
+ return vkImportFenceWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetFenceWin32HandleKHR(
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkGetFenceWin32HandleKHR_VkResult_return = vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+ return vkGetFenceWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_fd
+static VkResult entry_vkImportFenceFdKHR(
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
+ vkImportFenceFdKHR_VkResult_return = vkEnc->vkImportFenceFdKHR(device, pImportFenceFdInfo);
+ return vkImportFenceFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetFenceFdKHR(
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
+ vkGetFenceFdKHR_VkResult_return = vkEnc->vkGetFenceFdKHR(device, pGetFdInfo, pFd);
+ return vkGetFenceFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
+ return vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceFormats2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
+ return vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+static VkResult entry_vkGetPhysicalDeviceDisplayProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
+ return vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties);
+ return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayModeProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
+ vkGetDisplayModeProperties2KHR_VkResult_return = vkEnc->vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
+ return vkGetDisplayModeProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
+ vkGetDisplayPlaneCapabilities2KHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
+ return vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+static void entry_vkGetImageMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetBufferMemoryRequirements2KHR(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+static VkResult entry_vkCreateSamplerYcbcrConversionKHR(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
+ vkCreateSamplerYcbcrConversionKHR_VkResult_return = vkEnc->vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
+ return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
+}
+static void entry_vkDestroySamplerYcbcrConversionKHR(
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
+}
+#endif
+#ifdef VK_KHR_bind_memory2
+static VkResult entry_vkBindBufferMemory2KHR(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
+ vkBindBufferMemory2KHR_VkResult_return = vkEnc->vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
+ return vkBindBufferMemory2KHR_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory2KHR(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
+ vkBindImageMemory2KHR_VkResult_return = vkEnc->vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
+ return vkBindImageMemory2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance3
+static void entry_vkGetDescriptorSetLayoutSupportKHR(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
+}
+#endif
+#ifdef VK_KHR_draw_indirect_count
+static void entry_vkCmdDrawIndirectCountKHR(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirectCountKHR(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+static VkResult entry_vkGetSwapchainGrallocUsageANDROID(
+ VkDevice device,
+ VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
+ vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage);
+ return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
+}
+static VkResult entry_vkAcquireImageANDROID(
+ VkDevice device,
+ VkImage image,
+ int nativeFenceFd,
+ VkSemaphore semaphore,
+ VkFence fence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
+ vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence);
+ return vkAcquireImageANDROID_VkResult_return;
+}
+static VkResult entry_vkQueueSignalReleaseImageANDROID(
+ VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image,
+ int* pNativeFenceFd)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
+ vkQueueSignalReleaseImageANDROID_VkResult_return = vkEnc->vkQueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
+ return vkQueueSignalReleaseImageANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_debug_report
+static VkResult entry_vkCreateDebugReportCallbackEXT(
+ VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
+ vkCreateDebugReportCallbackEXT_VkResult_return = vkEnc->vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
+ return vkCreateDebugReportCallbackEXT_VkResult_return;
+}
+static void entry_vkDestroyDebugReportCallbackEXT(
+ VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
+}
+static void entry_vkDebugReportMessageEXT(
+ VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char* pLayerPrefix,
+ const char* pMessage)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
+}
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+static VkResult entry_vkDebugMarkerSetObjectTagEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+ vkDebugMarkerSetObjectTagEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
+ return vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
+static VkResult entry_vkDebugMarkerSetObjectNameEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+ vkDebugMarkerSetObjectNameEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
+ return vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
+static void entry_vkCmdDebugMarkerBeginEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
+}
+static void entry_vkCmdDebugMarkerEndEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDebugMarkerEndEXT(commandBuffer);
+}
+static void entry_vkCmdDebugMarkerInsertEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
+}
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+static void entry_vkCmdDrawIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+static VkResult entry_vkGetShaderInfoAMD(
+ VkDevice device,
+ VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType,
+ size_t* pInfoSize,
+ void* pInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+ vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
+ return vkGetShaderInfoAMD_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+static VkResult entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = vkEnc->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
+ return vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+static VkResult entry_vkGetMemoryWin32HandleNV(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+ vkGetMemoryWin32HandleNV_VkResult_return = vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle);
+ return vkGetMemoryWin32HandleNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+static VkResult entry_vkCreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
+ vkCreateViSurfaceNN_VkResult_return = vkEnc->vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateViSurfaceNN_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+static void entry_vkCmdBeginConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
+}
+static void entry_vkCmdEndConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndConditionalRenderingEXT(commandBuffer);
+}
+#endif
+#ifdef VK_NVX_device_generated_commands
+static void entry_vkCmdProcessCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
+}
+static void entry_vkCmdReserveSpaceForCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
+}
+static VkResult entry_vkCreateIndirectCommandsLayoutNVX(
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+ vkCreateIndirectCommandsLayoutNVX_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+ return vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
+static void entry_vkDestroyIndirectCommandsLayoutNVX(
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
+}
+static VkResult entry_vkCreateObjectTableNVX(
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+ vkCreateObjectTableNVX_VkResult_return = vkEnc->vkCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
+ return vkCreateObjectTableNVX_VkResult_return;
+}
+static void entry_vkDestroyObjectTableNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyObjectTableNVX(device, objectTable, pAllocator);
+}
+static VkResult entry_vkRegisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+ vkRegisterObjectsNVX_VkResult_return = vkEnc->vkRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
+ return vkRegisterObjectsNVX_VkResult_return;
+}
+static VkResult entry_vkUnregisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+ vkUnregisterObjectsNVX_VkResult_return = vkEnc->vkUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
+ return vkUnregisterObjectsNVX_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits);
+}
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+static void entry_vkCmdSetViewportWScalingNV(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
+}
+#endif
+#ifdef VK_EXT_direct_mode_display
+static VkResult entry_vkReleaseDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
+ vkReleaseDisplayEXT_VkResult_return = vkEnc->vkReleaseDisplayEXT(physicalDevice, display);
+ return vkReleaseDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+static VkResult entry_vkAcquireXlibDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
+ vkAcquireXlibDisplayEXT_VkResult_return = vkEnc->vkAcquireXlibDisplayEXT(physicalDevice, dpy, display);
+ return vkAcquireXlibDisplayEXT_VkResult_return;
+}
+static VkResult entry_vkGetRandROutputDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
+ vkGetRandROutputDisplayEXT_VkResult_return = vkEnc->vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
+ return vkGetRandROutputDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_surface_counter
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
+ return vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_control
+static VkResult entry_vkDisplayPowerControlEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+ vkDisplayPowerControlEXT_VkResult_return = vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
+ return vkDisplayPowerControlEXT_VkResult_return;
+}
+static VkResult entry_vkRegisterDeviceEventEXT(
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+ vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
+ return vkRegisterDeviceEventEXT_VkResult_return;
+}
+static VkResult entry_vkRegisterDisplayEventEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+ vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
+ return vkRegisterDisplayEventEXT_VkResult_return;
+}
+static VkResult entry_vkGetSwapchainCounterEXT(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+ vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
+ return vkGetSwapchainCounterEXT_VkResult_return;
+}
+#endif
+#ifdef VK_GOOGLE_display_timing
+static VkResult entry_vkGetRefreshCycleDurationGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+ vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
+ return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
+static VkResult entry_vkGetPastPresentationTimingGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+ vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
+ return vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+static void entry_vkCmdSetDiscardRectangleEXT(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
+}
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+static void entry_vkSetHdrMetadataEXT(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
+}
+#endif
+#ifdef VK_MVK_ios_surface
+static VkResult entry_vkCreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
+ vkCreateIOSSurfaceMVK_VkResult_return = vkEnc->vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateIOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_MVK_macos_surface
+static VkResult entry_vkCreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
+ vkCreateMacOSSurfaceMVK_VkResult_return = vkEnc->vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateMacOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+static VkResult entry_vkSetDebugUtilsObjectNameEXT(
+ VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+ vkSetDebugUtilsObjectNameEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
+ return vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
+static VkResult entry_vkSetDebugUtilsObjectTagEXT(
+ VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+ vkSetDebugUtilsObjectTagEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
+ return vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
+static void entry_vkQueueBeginDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
+}
+static void entry_vkQueueEndDebugUtilsLabelEXT(
+ VkQueue queue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkQueueEndDebugUtilsLabelEXT(queue);
+}
+static void entry_vkQueueInsertDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
+}
+static void entry_vkCmdBeginDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
+}
+static void entry_vkCmdEndDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndDebugUtilsLabelEXT(commandBuffer);
+}
+static void entry_vkCmdInsertDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
+}
+static VkResult entry_vkCreateDebugUtilsMessengerEXT(
+ VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+ vkCreateDebugUtilsMessengerEXT_VkResult_return = vkEnc->vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
+ return vkCreateDebugUtilsMessengerEXT_VkResult_return;
+}
+static void entry_vkDestroyDebugUtilsMessengerEXT(
+ VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
+}
+static void entry_vkSubmitDebugUtilsMessageEXT(
+ VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
+}
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID(
+ VkDevice device,
+ const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
+ vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = vkEnc->vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
+ return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
+}
+static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID(
+ VkDevice device,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
+ vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = vkEnc->vkGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
+ return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+static void entry_vkCmdSetSampleLocationsEXT(
+ VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
+}
+static void entry_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+ VkPhysicalDevice physicalDevice,
+ VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
+}
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+static VkResult entry_vkCreateValidationCacheEXT(
+ VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+ vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
+ return vkCreateValidationCacheEXT_VkResult_return;
+}
+static void entry_vkDestroyValidationCacheEXT(
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
+}
+static VkResult entry_vkMergeValidationCachesEXT(
+ VkDevice device,
+ VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+ vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
+ return vkMergeValidationCachesEXT_VkResult_return;
+}
+static VkResult entry_vkGetValidationCacheDataEXT(
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+ vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
+ return vkGetValidationCacheDataEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+static VkResult entry_vkGetMemoryHostPointerPropertiesEXT(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+ vkGetMemoryHostPointerPropertiesEXT_VkResult_return = vkEnc->vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
+ return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_buffer_marker
+static void entry_vkCmdWriteBufferMarkerAMD(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ uint32_t marker)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
+}
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+static void entry_vkCmdSetCheckpointNV(
+ VkCommandBuffer commandBuffer,
+ const void* pCheckpointMarker)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
+}
+static void entry_vkGetQueueCheckpointDataNV(
+ VkQueue queue,
+ uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
+}
+#endif
+void* goldfish_vulkan_get_proc_address(const char* name){
+#ifdef VK_VERSION_1_0
+ if (!strcmp(name, "vkCreateInstance"))
+ {
+ return (void*)entry_vkCreateInstance;
+ }
+ if (!strcmp(name, "vkDestroyInstance"))
+ {
+ return (void*)entry_vkDestroyInstance;
+ }
+ if (!strcmp(name, "vkEnumeratePhysicalDevices"))
+ {
+ return (void*)entry_vkEnumeratePhysicalDevices;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFeatures;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFormatProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
+ }
+ if (!strcmp(name, "vkGetInstanceProcAddr"))
+ {
+ return (void*)entry_vkGetInstanceProcAddr;
+ }
+ if (!strcmp(name, "vkGetDeviceProcAddr"))
+ {
+ return (void*)entry_vkGetDeviceProcAddr;
+ }
+ if (!strcmp(name, "vkCreateDevice"))
+ {
+ return (void*)entry_vkCreateDevice;
+ }
+ if (!strcmp(name, "vkDestroyDevice"))
+ {
+ return (void*)entry_vkDestroyDevice;
+ }
+ if (!strcmp(name, "vkEnumerateInstanceExtensionProperties"))
+ {
+ return (void*)entry_vkEnumerateInstanceExtensionProperties;
+ }
+ if (!strcmp(name, "vkEnumerateDeviceExtensionProperties"))
+ {
+ return (void*)entry_vkEnumerateDeviceExtensionProperties;
+ }
+ if (!strcmp(name, "vkEnumerateInstanceLayerProperties"))
+ {
+ return (void*)entry_vkEnumerateInstanceLayerProperties;
+ }
+ if (!strcmp(name, "vkEnumerateDeviceLayerProperties"))
+ {
+ return (void*)entry_vkEnumerateDeviceLayerProperties;
+ }
+ if (!strcmp(name, "vkGetDeviceQueue"))
+ {
+ return (void*)entry_vkGetDeviceQueue;
+ }
+ if (!strcmp(name, "vkQueueSubmit"))
+ {
+ return (void*)entry_vkQueueSubmit;
+ }
+ if (!strcmp(name, "vkQueueWaitIdle"))
+ {
+ return (void*)entry_vkQueueWaitIdle;
+ }
+ if (!strcmp(name, "vkDeviceWaitIdle"))
+ {
+ return (void*)entry_vkDeviceWaitIdle;
+ }
+ if (!strcmp(name, "vkAllocateMemory"))
+ {
+ return (void*)entry_vkAllocateMemory;
+ }
+ if (!strcmp(name, "vkFreeMemory"))
+ {
+ return (void*)entry_vkFreeMemory;
+ }
+ if (!strcmp(name, "vkMapMemory"))
+ {
+ return (void*)entry_vkMapMemory;
+ }
+ if (!strcmp(name, "vkUnmapMemory"))
+ {
+ return (void*)entry_vkUnmapMemory;
+ }
+ if (!strcmp(name, "vkFlushMappedMemoryRanges"))
+ {
+ return (void*)entry_vkFlushMappedMemoryRanges;
+ }
+ if (!strcmp(name, "vkInvalidateMappedMemoryRanges"))
+ {
+ return (void*)entry_vkInvalidateMappedMemoryRanges;
+ }
+ if (!strcmp(name, "vkGetDeviceMemoryCommitment"))
+ {
+ return (void*)entry_vkGetDeviceMemoryCommitment;
+ }
+ if (!strcmp(name, "vkBindBufferMemory"))
+ {
+ return (void*)entry_vkBindBufferMemory;
+ }
+ if (!strcmp(name, "vkBindImageMemory"))
+ {
+ return (void*)entry_vkBindImageMemory;
+ }
+ if (!strcmp(name, "vkGetBufferMemoryRequirements"))
+ {
+ return (void*)entry_vkGetBufferMemoryRequirements;
+ }
+ if (!strcmp(name, "vkGetImageMemoryRequirements"))
+ {
+ return (void*)entry_vkGetImageMemoryRequirements;
+ }
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements"))
+ {
+ return (void*)entry_vkGetImageSparseMemoryRequirements;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
+ }
+ if (!strcmp(name, "vkQueueBindSparse"))
+ {
+ return (void*)entry_vkQueueBindSparse;
+ }
+ if (!strcmp(name, "vkCreateFence"))
+ {
+ return (void*)entry_vkCreateFence;
+ }
+ if (!strcmp(name, "vkDestroyFence"))
+ {
+ return (void*)entry_vkDestroyFence;
+ }
+ if (!strcmp(name, "vkResetFences"))
+ {
+ return (void*)entry_vkResetFences;
+ }
+ if (!strcmp(name, "vkGetFenceStatus"))
+ {
+ return (void*)entry_vkGetFenceStatus;
+ }
+ if (!strcmp(name, "vkWaitForFences"))
+ {
+ return (void*)entry_vkWaitForFences;
+ }
+ if (!strcmp(name, "vkCreateSemaphore"))
+ {
+ return (void*)entry_vkCreateSemaphore;
+ }
+ if (!strcmp(name, "vkDestroySemaphore"))
+ {
+ return (void*)entry_vkDestroySemaphore;
+ }
+ if (!strcmp(name, "vkCreateEvent"))
+ {
+ return (void*)entry_vkCreateEvent;
+ }
+ if (!strcmp(name, "vkDestroyEvent"))
+ {
+ return (void*)entry_vkDestroyEvent;
+ }
+ if (!strcmp(name, "vkGetEventStatus"))
+ {
+ return (void*)entry_vkGetEventStatus;
+ }
+ if (!strcmp(name, "vkSetEvent"))
+ {
+ return (void*)entry_vkSetEvent;
+ }
+ if (!strcmp(name, "vkResetEvent"))
+ {
+ return (void*)entry_vkResetEvent;
+ }
+ if (!strcmp(name, "vkCreateQueryPool"))
+ {
+ return (void*)entry_vkCreateQueryPool;
+ }
+ if (!strcmp(name, "vkDestroyQueryPool"))
+ {
+ return (void*)entry_vkDestroyQueryPool;
+ }
+ if (!strcmp(name, "vkGetQueryPoolResults"))
+ {
+ return (void*)entry_vkGetQueryPoolResults;
+ }
+ if (!strcmp(name, "vkCreateBuffer"))
+ {
+ return (void*)entry_vkCreateBuffer;
+ }
+ if (!strcmp(name, "vkDestroyBuffer"))
+ {
+ return (void*)entry_vkDestroyBuffer;
+ }
+ if (!strcmp(name, "vkCreateBufferView"))
+ {
+ return (void*)entry_vkCreateBufferView;
+ }
+ if (!strcmp(name, "vkDestroyBufferView"))
+ {
+ return (void*)entry_vkDestroyBufferView;
+ }
+ if (!strcmp(name, "vkCreateImage"))
+ {
+ return (void*)entry_vkCreateImage;
+ }
+ if (!strcmp(name, "vkDestroyImage"))
+ {
+ return (void*)entry_vkDestroyImage;
+ }
+ if (!strcmp(name, "vkGetImageSubresourceLayout"))
+ {
+ return (void*)entry_vkGetImageSubresourceLayout;
+ }
+ if (!strcmp(name, "vkCreateImageView"))
+ {
+ return (void*)entry_vkCreateImageView;
+ }
+ if (!strcmp(name, "vkDestroyImageView"))
+ {
+ return (void*)entry_vkDestroyImageView;
+ }
+ if (!strcmp(name, "vkCreateShaderModule"))
+ {
+ return (void*)entry_vkCreateShaderModule;
+ }
+ if (!strcmp(name, "vkDestroyShaderModule"))
+ {
+ return (void*)entry_vkDestroyShaderModule;
+ }
+ if (!strcmp(name, "vkCreatePipelineCache"))
+ {
+ return (void*)entry_vkCreatePipelineCache;
+ }
+ if (!strcmp(name, "vkDestroyPipelineCache"))
+ {
+ return (void*)entry_vkDestroyPipelineCache;
+ }
+ if (!strcmp(name, "vkGetPipelineCacheData"))
+ {
+ return (void*)entry_vkGetPipelineCacheData;
+ }
+ if (!strcmp(name, "vkMergePipelineCaches"))
+ {
+ return (void*)entry_vkMergePipelineCaches;
+ }
+ if (!strcmp(name, "vkCreateGraphicsPipelines"))
+ {
+ return (void*)entry_vkCreateGraphicsPipelines;
+ }
+ if (!strcmp(name, "vkCreateComputePipelines"))
+ {
+ return (void*)entry_vkCreateComputePipelines;
+ }
+ if (!strcmp(name, "vkDestroyPipeline"))
+ {
+ return (void*)entry_vkDestroyPipeline;
+ }
+ if (!strcmp(name, "vkCreatePipelineLayout"))
+ {
+ return (void*)entry_vkCreatePipelineLayout;
+ }
+ if (!strcmp(name, "vkDestroyPipelineLayout"))
+ {
+ return (void*)entry_vkDestroyPipelineLayout;
+ }
+ if (!strcmp(name, "vkCreateSampler"))
+ {
+ return (void*)entry_vkCreateSampler;
+ }
+ if (!strcmp(name, "vkDestroySampler"))
+ {
+ return (void*)entry_vkDestroySampler;
+ }
+ if (!strcmp(name, "vkCreateDescriptorSetLayout"))
+ {
+ return (void*)entry_vkCreateDescriptorSetLayout;
+ }
+ if (!strcmp(name, "vkDestroyDescriptorSetLayout"))
+ {
+ return (void*)entry_vkDestroyDescriptorSetLayout;
+ }
+ if (!strcmp(name, "vkCreateDescriptorPool"))
+ {
+ return (void*)entry_vkCreateDescriptorPool;
+ }
+ if (!strcmp(name, "vkDestroyDescriptorPool"))
+ {
+ return (void*)entry_vkDestroyDescriptorPool;
+ }
+ if (!strcmp(name, "vkResetDescriptorPool"))
+ {
+ return (void*)entry_vkResetDescriptorPool;
+ }
+ if (!strcmp(name, "vkAllocateDescriptorSets"))
+ {
+ return (void*)entry_vkAllocateDescriptorSets;
+ }
+ if (!strcmp(name, "vkFreeDescriptorSets"))
+ {
+ return (void*)entry_vkFreeDescriptorSets;
+ }
+ if (!strcmp(name, "vkUpdateDescriptorSets"))
+ {
+ return (void*)entry_vkUpdateDescriptorSets;
+ }
+ if (!strcmp(name, "vkCreateFramebuffer"))
+ {
+ return (void*)entry_vkCreateFramebuffer;
+ }
+ if (!strcmp(name, "vkDestroyFramebuffer"))
+ {
+ return (void*)entry_vkDestroyFramebuffer;
+ }
+ if (!strcmp(name, "vkCreateRenderPass"))
+ {
+ return (void*)entry_vkCreateRenderPass;
+ }
+ if (!strcmp(name, "vkDestroyRenderPass"))
+ {
+ return (void*)entry_vkDestroyRenderPass;
+ }
+ if (!strcmp(name, "vkGetRenderAreaGranularity"))
+ {
+ return (void*)entry_vkGetRenderAreaGranularity;
+ }
+ if (!strcmp(name, "vkCreateCommandPool"))
+ {
+ return (void*)entry_vkCreateCommandPool;
+ }
+ if (!strcmp(name, "vkDestroyCommandPool"))
+ {
+ return (void*)entry_vkDestroyCommandPool;
+ }
+ if (!strcmp(name, "vkResetCommandPool"))
+ {
+ return (void*)entry_vkResetCommandPool;
+ }
+ if (!strcmp(name, "vkAllocateCommandBuffers"))
+ {
+ return (void*)entry_vkAllocateCommandBuffers;
+ }
+ if (!strcmp(name, "vkFreeCommandBuffers"))
+ {
+ return (void*)entry_vkFreeCommandBuffers;
+ }
+ if (!strcmp(name, "vkBeginCommandBuffer"))
+ {
+ return (void*)entry_vkBeginCommandBuffer;
+ }
+ if (!strcmp(name, "vkEndCommandBuffer"))
+ {
+ return (void*)entry_vkEndCommandBuffer;
+ }
+ if (!strcmp(name, "vkResetCommandBuffer"))
+ {
+ return (void*)entry_vkResetCommandBuffer;
+ }
+ if (!strcmp(name, "vkCmdBindPipeline"))
+ {
+ return (void*)entry_vkCmdBindPipeline;
+ }
+ if (!strcmp(name, "vkCmdSetViewport"))
+ {
+ return (void*)entry_vkCmdSetViewport;
+ }
+ if (!strcmp(name, "vkCmdSetScissor"))
+ {
+ return (void*)entry_vkCmdSetScissor;
+ }
+ if (!strcmp(name, "vkCmdSetLineWidth"))
+ {
+ return (void*)entry_vkCmdSetLineWidth;
+ }
+ if (!strcmp(name, "vkCmdSetDepthBias"))
+ {
+ return (void*)entry_vkCmdSetDepthBias;
+ }
+ if (!strcmp(name, "vkCmdSetBlendConstants"))
+ {
+ return (void*)entry_vkCmdSetBlendConstants;
+ }
+ if (!strcmp(name, "vkCmdSetDepthBounds"))
+ {
+ return (void*)entry_vkCmdSetDepthBounds;
+ }
+ if (!strcmp(name, "vkCmdSetStencilCompareMask"))
+ {
+ return (void*)entry_vkCmdSetStencilCompareMask;
+ }
+ if (!strcmp(name, "vkCmdSetStencilWriteMask"))
+ {
+ return (void*)entry_vkCmdSetStencilWriteMask;
+ }
+ if (!strcmp(name, "vkCmdSetStencilReference"))
+ {
+ return (void*)entry_vkCmdSetStencilReference;
+ }
+ if (!strcmp(name, "vkCmdBindDescriptorSets"))
+ {
+ return (void*)entry_vkCmdBindDescriptorSets;
+ }
+ if (!strcmp(name, "vkCmdBindIndexBuffer"))
+ {
+ return (void*)entry_vkCmdBindIndexBuffer;
+ }
+ if (!strcmp(name, "vkCmdBindVertexBuffers"))
+ {
+ return (void*)entry_vkCmdBindVertexBuffers;
+ }
+ if (!strcmp(name, "vkCmdDraw"))
+ {
+ return (void*)entry_vkCmdDraw;
+ }
+ if (!strcmp(name, "vkCmdDrawIndexed"))
+ {
+ return (void*)entry_vkCmdDrawIndexed;
+ }
+ if (!strcmp(name, "vkCmdDrawIndirect"))
+ {
+ return (void*)entry_vkCmdDrawIndirect;
+ }
+ if (!strcmp(name, "vkCmdDrawIndexedIndirect"))
+ {
+ return (void*)entry_vkCmdDrawIndexedIndirect;
+ }
+ if (!strcmp(name, "vkCmdDispatch"))
+ {
+ return (void*)entry_vkCmdDispatch;
+ }
+ if (!strcmp(name, "vkCmdDispatchIndirect"))
+ {
+ return (void*)entry_vkCmdDispatchIndirect;
+ }
+ if (!strcmp(name, "vkCmdCopyBuffer"))
+ {
+ return (void*)entry_vkCmdCopyBuffer;
+ }
+ if (!strcmp(name, "vkCmdCopyImage"))
+ {
+ return (void*)entry_vkCmdCopyImage;
+ }
+ if (!strcmp(name, "vkCmdBlitImage"))
+ {
+ return (void*)entry_vkCmdBlitImage;
+ }
+ if (!strcmp(name, "vkCmdCopyBufferToImage"))
+ {
+ return (void*)entry_vkCmdCopyBufferToImage;
+ }
+ if (!strcmp(name, "vkCmdCopyImageToBuffer"))
+ {
+ return (void*)entry_vkCmdCopyImageToBuffer;
+ }
+ if (!strcmp(name, "vkCmdUpdateBuffer"))
+ {
+ return (void*)entry_vkCmdUpdateBuffer;
+ }
+ if (!strcmp(name, "vkCmdFillBuffer"))
+ {
+ return (void*)entry_vkCmdFillBuffer;
+ }
+ if (!strcmp(name, "vkCmdClearColorImage"))
+ {
+ return (void*)entry_vkCmdClearColorImage;
+ }
+ if (!strcmp(name, "vkCmdClearDepthStencilImage"))
+ {
+ return (void*)entry_vkCmdClearDepthStencilImage;
+ }
+ if (!strcmp(name, "vkCmdClearAttachments"))
+ {
+ return (void*)entry_vkCmdClearAttachments;
+ }
+ if (!strcmp(name, "vkCmdResolveImage"))
+ {
+ return (void*)entry_vkCmdResolveImage;
+ }
+ if (!strcmp(name, "vkCmdSetEvent"))
+ {
+ return (void*)entry_vkCmdSetEvent;
+ }
+ if (!strcmp(name, "vkCmdResetEvent"))
+ {
+ return (void*)entry_vkCmdResetEvent;
+ }
+ if (!strcmp(name, "vkCmdWaitEvents"))
+ {
+ return (void*)entry_vkCmdWaitEvents;
+ }
+ if (!strcmp(name, "vkCmdPipelineBarrier"))
+ {
+ return (void*)entry_vkCmdPipelineBarrier;
+ }
+ if (!strcmp(name, "vkCmdBeginQuery"))
+ {
+ return (void*)entry_vkCmdBeginQuery;
+ }
+ if (!strcmp(name, "vkCmdEndQuery"))
+ {
+ return (void*)entry_vkCmdEndQuery;
+ }
+ if (!strcmp(name, "vkCmdResetQueryPool"))
+ {
+ return (void*)entry_vkCmdResetQueryPool;
+ }
+ if (!strcmp(name, "vkCmdWriteTimestamp"))
+ {
+ return (void*)entry_vkCmdWriteTimestamp;
+ }
+ if (!strcmp(name, "vkCmdCopyQueryPoolResults"))
+ {
+ return (void*)entry_vkCmdCopyQueryPoolResults;
+ }
+ if (!strcmp(name, "vkCmdPushConstants"))
+ {
+ return (void*)entry_vkCmdPushConstants;
+ }
+ if (!strcmp(name, "vkCmdBeginRenderPass"))
+ {
+ return (void*)entry_vkCmdBeginRenderPass;
+ }
+ if (!strcmp(name, "vkCmdNextSubpass"))
+ {
+ return (void*)entry_vkCmdNextSubpass;
+ }
+ if (!strcmp(name, "vkCmdEndRenderPass"))
+ {
+ return (void*)entry_vkCmdEndRenderPass;
+ }
+ if (!strcmp(name, "vkCmdExecuteCommands"))
+ {
+ return (void*)entry_vkCmdExecuteCommands;
+ }
+#endif
+#ifdef VK_VERSION_1_1
+ if (!strcmp(name, "vkEnumerateInstanceVersion"))
+ {
+ return (void*)entry_vkEnumerateInstanceVersion;
+ }
+ if (!strcmp(name, "vkBindBufferMemory2"))
+ {
+ return (void*)entry_vkBindBufferMemory2;
+ }
+ if (!strcmp(name, "vkBindImageMemory2"))
+ {
+ return (void*)entry_vkBindImageMemory2;
+ }
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures"))
+ {
+ return (void*)entry_vkGetDeviceGroupPeerMemoryFeatures;
+ }
+ if (!strcmp(name, "vkCmdSetDeviceMask"))
+ {
+ return (void*)entry_vkCmdSetDeviceMask;
+ }
+ if (!strcmp(name, "vkCmdDispatchBase"))
+ {
+ return (void*)entry_vkCmdDispatchBase;
+ }
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups"))
+ {
+ return nullptr;
+ }
+ if (!strcmp(name, "vkGetImageMemoryRequirements2"))
+ {
+ return (void*)entry_vkGetImageMemoryRequirements2;
+ }
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2"))
+ {
+ return (void*)entry_vkGetBufferMemoryRequirements2;
+ }
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2"))
+ {
+ return (void*)entry_vkGetImageSparseMemoryRequirements2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFeatures2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFormatProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceImageFormatProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMemoryProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2;
+ }
+ if (!strcmp(name, "vkTrimCommandPool"))
+ {
+ return (void*)entry_vkTrimCommandPool;
+ }
+ if (!strcmp(name, "vkGetDeviceQueue2"))
+ {
+ return (void*)entry_vkGetDeviceQueue2;
+ }
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversion"))
+ {
+ return (void*)entry_vkCreateSamplerYcbcrConversion;
+ }
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversion"))
+ {
+ return (void*)entry_vkDestroySamplerYcbcrConversion;
+ }
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplate"))
+ {
+ return (void*)entry_vkCreateDescriptorUpdateTemplate;
+ }
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate"))
+ {
+ return (void*)entry_vkDestroyDescriptorUpdateTemplate;
+ }
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate"))
+ {
+ return (void*)entry_vkUpdateDescriptorSetWithTemplate;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalBufferProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalFenceProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties;
+ }
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupport"))
+ {
+ return (void*)entry_vkGetDescriptorSetLayoutSupport;
+ }
+#endif
+#ifdef VK_KHR_surface
+ if (!strcmp(name, "vkDestroySurfaceKHR"))
+ {
+ return (void*)entry_vkDestroySurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceSupportKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceFormatsKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfacePresentModesKHR;
+ }
+#endif
+#ifdef VK_KHR_swapchain
+ if (!strcmp(name, "vkCreateSwapchainKHR"))
+ {
+ return (void*)entry_vkCreateSwapchainKHR;
+ }
+ if (!strcmp(name, "vkDestroySwapchainKHR"))
+ {
+ return (void*)entry_vkDestroySwapchainKHR;
+ }
+ if (!strcmp(name, "vkGetSwapchainImagesKHR"))
+ {
+ return (void*)entry_vkGetSwapchainImagesKHR;
+ }
+ if (!strcmp(name, "vkAcquireNextImageKHR"))
+ {
+ return (void*)entry_vkAcquireNextImageKHR;
+ }
+ if (!strcmp(name, "vkQueuePresentKHR"))
+ {
+ return (void*)entry_vkQueuePresentKHR;
+ }
+ if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR"))
+ {
+ return (void*)entry_vkGetDeviceGroupPresentCapabilitiesKHR;
+ }
+ if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR"))
+ {
+ return (void*)entry_vkGetDeviceGroupSurfacePresentModesKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR;
+ }
+ if (!strcmp(name, "vkAcquireNextImage2KHR"))
+ {
+ return (void*)entry_vkAcquireNextImage2KHR;
+ }
+#endif
+#ifdef VK_KHR_display
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceDisplayPropertiesKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+ }
+ if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR"))
+ {
+ return (void*)entry_vkGetDisplayPlaneSupportedDisplaysKHR;
+ }
+ if (!strcmp(name, "vkGetDisplayModePropertiesKHR"))
+ {
+ return (void*)entry_vkGetDisplayModePropertiesKHR;
+ }
+ if (!strcmp(name, "vkCreateDisplayModeKHR"))
+ {
+ return (void*)entry_vkCreateDisplayModeKHR;
+ }
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR"))
+ {
+ return (void*)entry_vkGetDisplayPlaneCapabilitiesKHR;
+ }
+ if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateDisplayPlaneSurfaceKHR;
+ }
+#endif
+#ifdef VK_KHR_display_swapchain
+ if (!strcmp(name, "vkCreateSharedSwapchainsKHR"))
+ {
+ return (void*)entry_vkCreateSharedSwapchainsKHR;
+ }
+#endif
+#ifdef VK_KHR_xlib_surface
+ if (!strcmp(name, "vkCreateXlibSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateXlibSurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceXlibPresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_xcb_surface
+ if (!strcmp(name, "vkCreateXcbSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateXcbSurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceXcbPresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_wayland_surface
+ if (!strcmp(name, "vkCreateWaylandSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateWaylandSurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_mir_surface
+ if (!strcmp(name, "vkCreateMirSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateMirSurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMirPresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMirPresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_android_surface
+ if (!strcmp(name, "vkCreateAndroidSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateAndroidSurfaceKHR;
+ }
+#endif
+#ifdef VK_KHR_win32_surface
+ if (!strcmp(name, "vkCreateWin32SurfaceKHR"))
+ {
+ return (void*)entry_vkCreateWin32SurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceWin32PresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFeatures2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+ }
+#endif
+#ifdef VK_KHR_device_group
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR"))
+ {
+ return (void*)entry_vkGetDeviceGroupPeerMemoryFeaturesKHR;
+ }
+ if (!strcmp(name, "vkCmdSetDeviceMaskKHR"))
+ {
+ return (void*)entry_vkCmdSetDeviceMaskKHR;
+ }
+ if (!strcmp(name, "vkCmdDispatchBaseKHR"))
+ {
+ return (void*)entry_vkCmdDispatchBaseKHR;
+ }
+#endif
+#ifdef VK_KHR_maintenance1
+ if (!strcmp(name, "vkTrimCommandPoolKHR"))
+ {
+ return (void*)entry_vkTrimCommandPoolKHR;
+ }
+#endif
+#ifdef VK_KHR_device_group_creation
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR"))
+ {
+ return (void*)entry_vkEnumeratePhysicalDeviceGroupsKHR;
+ }
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_memory_win32
+ if (!strcmp(name, "vkGetMemoryWin32HandleKHR"))
+ {
+ return (void*)entry_vkGetMemoryWin32HandleKHR;
+ }
+ if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR"))
+ {
+ return (void*)entry_vkGetMemoryWin32HandlePropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_memory_fd
+ if (!strcmp(name, "vkGetMemoryFdKHR"))
+ {
+ return (void*)entry_vkGetMemoryFdKHR;
+ }
+ if (!strcmp(name, "vkGetMemoryFdPropertiesKHR"))
+ {
+ return (void*)entry_vkGetMemoryFdPropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+ if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR"))
+ {
+ return (void*)entry_vkImportSemaphoreWin32HandleKHR;
+ }
+ if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR"))
+ {
+ return (void*)entry_vkGetSemaphoreWin32HandleKHR;
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+ if (!strcmp(name, "vkImportSemaphoreFdKHR"))
+ {
+ return (void*)entry_vkImportSemaphoreFdKHR;
+ }
+ if (!strcmp(name, "vkGetSemaphoreFdKHR"))
+ {
+ return (void*)entry_vkGetSemaphoreFdKHR;
+ }
+#endif
+#ifdef VK_KHR_push_descriptor
+ if (!strcmp(name, "vkCmdPushDescriptorSetKHR"))
+ {
+ return (void*)entry_vkCmdPushDescriptorSetKHR;
+ }
+ if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR"))
+ {
+ return (void*)entry_vkCmdPushDescriptorSetWithTemplateKHR;
+ }
+#endif
+#ifdef VK_KHR_descriptor_update_template
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR"))
+ {
+ return (void*)entry_vkCreateDescriptorUpdateTemplateKHR;
+ }
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR"))
+ {
+ return (void*)entry_vkDestroyDescriptorUpdateTemplateKHR;
+ }
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR"))
+ {
+ return (void*)entry_vkUpdateDescriptorSetWithTemplateKHR;
+ }
+#endif
+#ifdef VK_KHR_create_renderpass2
+ if (!strcmp(name, "vkCreateRenderPass2KHR"))
+ {
+ return (void*)entry_vkCreateRenderPass2KHR;
+ }
+ if (!strcmp(name, "vkCmdBeginRenderPass2KHR"))
+ {
+ return (void*)entry_vkCmdBeginRenderPass2KHR;
+ }
+ if (!strcmp(name, "vkCmdNextSubpass2KHR"))
+ {
+ return (void*)entry_vkCmdNextSubpass2KHR;
+ }
+ if (!strcmp(name, "vkCmdEndRenderPass2KHR"))
+ {
+ return (void*)entry_vkCmdEndRenderPass2KHR;
+ }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+ if (!strcmp(name, "vkGetSwapchainStatusKHR"))
+ {
+ return (void*)entry_vkGetSwapchainStatusKHR;
+ }
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_fence_win32
+ if (!strcmp(name, "vkImportFenceWin32HandleKHR"))
+ {
+ return (void*)entry_vkImportFenceWin32HandleKHR;
+ }
+ if (!strcmp(name, "vkGetFenceWin32HandleKHR"))
+ {
+ return (void*)entry_vkGetFenceWin32HandleKHR;
+ }
+#endif
+#ifdef VK_KHR_external_fence_fd
+ if (!strcmp(name, "vkImportFenceFdKHR"))
+ {
+ return (void*)entry_vkImportFenceFdKHR;
+ }
+ if (!strcmp(name, "vkGetFenceFdKHR"))
+ {
+ return (void*)entry_vkGetFenceFdKHR;
+ }
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceFormats2KHR;
+ }
+#endif
+#ifdef VK_KHR_get_display_properties2
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceDisplayProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetDisplayModeProperties2KHR"))
+ {
+ return (void*)entry_vkGetDisplayModeProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR"))
+ {
+ return (void*)entry_vkGetDisplayPlaneCapabilities2KHR;
+ }
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+ if (!strcmp(name, "vkGetImageMemoryRequirements2KHR"))
+ {
+ return (void*)entry_vkGetImageMemoryRequirements2KHR;
+ }
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR"))
+ {
+ return (void*)entry_vkGetBufferMemoryRequirements2KHR;
+ }
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR"))
+ {
+ return (void*)entry_vkGetImageSparseMemoryRequirements2KHR;
+ }
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR"))
+ {
+ return (void*)entry_vkCreateSamplerYcbcrConversionKHR;
+ }
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR"))
+ {
+ return (void*)entry_vkDestroySamplerYcbcrConversionKHR;
+ }
+#endif
+#ifdef VK_KHR_bind_memory2
+ if (!strcmp(name, "vkBindBufferMemory2KHR"))
+ {
+ return (void*)entry_vkBindBufferMemory2KHR;
+ }
+ if (!strcmp(name, "vkBindImageMemory2KHR"))
+ {
+ return (void*)entry_vkBindImageMemory2KHR;
+ }
+#endif
+#ifdef VK_KHR_maintenance3
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR"))
+ {
+ return (void*)entry_vkGetDescriptorSetLayoutSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_draw_indirect_count
+ if (!strcmp(name, "vkCmdDrawIndirectCountKHR"))
+ {
+ return (void*)entry_vkCmdDrawIndirectCountKHR;
+ }
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR"))
+ {
+ return (void*)entry_vkCmdDrawIndexedIndirectCountKHR;
+ }
+#endif
+#ifdef VK_ANDROID_native_buffer
+ if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID"))
+ {
+ return (void*)entry_vkGetSwapchainGrallocUsageANDROID;
+ }
+ if (!strcmp(name, "vkAcquireImageANDROID"))
+ {
+ return (void*)entry_vkAcquireImageANDROID;
+ }
+ if (!strcmp(name, "vkQueueSignalReleaseImageANDROID"))
+ {
+ return (void*)entry_vkQueueSignalReleaseImageANDROID;
+ }
+#endif
+#ifdef VK_EXT_debug_report
+ if (!strcmp(name, "vkCreateDebugReportCallbackEXT"))
+ {
+ return (void*)entry_vkCreateDebugReportCallbackEXT;
+ }
+ if (!strcmp(name, "vkDestroyDebugReportCallbackEXT"))
+ {
+ return (void*)entry_vkDestroyDebugReportCallbackEXT;
+ }
+ if (!strcmp(name, "vkDebugReportMessageEXT"))
+ {
+ return (void*)entry_vkDebugReportMessageEXT;
+ }
+#endif
+#ifdef VK_EXT_debug_marker
+ if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT"))
+ {
+ return (void*)entry_vkDebugMarkerSetObjectTagEXT;
+ }
+ if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT"))
+ {
+ return (void*)entry_vkDebugMarkerSetObjectNameEXT;
+ }
+ if (!strcmp(name, "vkCmdDebugMarkerBeginEXT"))
+ {
+ return (void*)entry_vkCmdDebugMarkerBeginEXT;
+ }
+ if (!strcmp(name, "vkCmdDebugMarkerEndEXT"))
+ {
+ return (void*)entry_vkCmdDebugMarkerEndEXT;
+ }
+ if (!strcmp(name, "vkCmdDebugMarkerInsertEXT"))
+ {
+ return (void*)entry_vkCmdDebugMarkerInsertEXT;
+ }
+#endif
+#ifdef VK_AMD_draw_indirect_count
+ if (!strcmp(name, "vkCmdDrawIndirectCountAMD"))
+ {
+ return (void*)entry_vkCmdDrawIndirectCountAMD;
+ }
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD"))
+ {
+ return (void*)entry_vkCmdDrawIndexedIndirectCountAMD;
+ }
+#endif
+#ifdef VK_AMD_shader_info
+ if (!strcmp(name, "vkGetShaderInfoAMD"))
+ {
+ return (void*)entry_vkGetShaderInfoAMD;
+ }
+#endif
+#ifdef VK_NV_external_memory_capabilities
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+ }
+#endif
+#ifdef VK_NV_external_memory_win32
+ if (!strcmp(name, "vkGetMemoryWin32HandleNV"))
+ {
+ return (void*)entry_vkGetMemoryWin32HandleNV;
+ }
+#endif
+#ifdef VK_NN_vi_surface
+ if (!strcmp(name, "vkCreateViSurfaceNN"))
+ {
+ return (void*)entry_vkCreateViSurfaceNN;
+ }
+#endif
+#ifdef VK_EXT_conditional_rendering
+ if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT"))
+ {
+ return (void*)entry_vkCmdBeginConditionalRenderingEXT;
+ }
+ if (!strcmp(name, "vkCmdEndConditionalRenderingEXT"))
+ {
+ return (void*)entry_vkCmdEndConditionalRenderingEXT;
+ }
+#endif
+#ifdef VK_NVX_device_generated_commands
+ if (!strcmp(name, "vkCmdProcessCommandsNVX"))
+ {
+ return (void*)entry_vkCmdProcessCommandsNVX;
+ }
+ if (!strcmp(name, "vkCmdReserveSpaceForCommandsNVX"))
+ {
+ return (void*)entry_vkCmdReserveSpaceForCommandsNVX;
+ }
+ if (!strcmp(name, "vkCreateIndirectCommandsLayoutNVX"))
+ {
+ return (void*)entry_vkCreateIndirectCommandsLayoutNVX;
+ }
+ if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNVX"))
+ {
+ return (void*)entry_vkDestroyIndirectCommandsLayoutNVX;
+ }
+ if (!strcmp(name, "vkCreateObjectTableNVX"))
+ {
+ return (void*)entry_vkCreateObjectTableNVX;
+ }
+ if (!strcmp(name, "vkDestroyObjectTableNVX"))
+ {
+ return (void*)entry_vkDestroyObjectTableNVX;
+ }
+ if (!strcmp(name, "vkRegisterObjectsNVX"))
+ {
+ return (void*)entry_vkRegisterObjectsNVX;
+ }
+ if (!strcmp(name, "vkUnregisterObjectsNVX"))
+ {
+ return (void*)entry_vkUnregisterObjectsNVX;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+ }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+ if (!strcmp(name, "vkCmdSetViewportWScalingNV"))
+ {
+ return (void*)entry_vkCmdSetViewportWScalingNV;
+ }
+#endif
+#ifdef VK_EXT_direct_mode_display
+ if (!strcmp(name, "vkReleaseDisplayEXT"))
+ {
+ return (void*)entry_vkReleaseDisplayEXT;
+ }
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+ if (!strcmp(name, "vkAcquireXlibDisplayEXT"))
+ {
+ return (void*)entry_vkAcquireXlibDisplayEXT;
+ }
+ if (!strcmp(name, "vkGetRandROutputDisplayEXT"))
+ {
+ return (void*)entry_vkGetRandROutputDisplayEXT;
+ }
+#endif
+#ifdef VK_EXT_display_surface_counter
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+ }
+#endif
+#ifdef VK_EXT_display_control
+ if (!strcmp(name, "vkDisplayPowerControlEXT"))
+ {
+ return (void*)entry_vkDisplayPowerControlEXT;
+ }
+ if (!strcmp(name, "vkRegisterDeviceEventEXT"))
+ {
+ return (void*)entry_vkRegisterDeviceEventEXT;
+ }
+ if (!strcmp(name, "vkRegisterDisplayEventEXT"))
+ {
+ return (void*)entry_vkRegisterDisplayEventEXT;
+ }
+ if (!strcmp(name, "vkGetSwapchainCounterEXT"))
+ {
+ return (void*)entry_vkGetSwapchainCounterEXT;
+ }
+#endif
+#ifdef VK_GOOGLE_display_timing
+ if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE"))
+ {
+ return (void*)entry_vkGetRefreshCycleDurationGOOGLE;
+ }
+ if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE"))
+ {
+ return (void*)entry_vkGetPastPresentationTimingGOOGLE;
+ }
+#endif
+#ifdef VK_EXT_discard_rectangles
+ if (!strcmp(name, "vkCmdSetDiscardRectangleEXT"))
+ {
+ return (void*)entry_vkCmdSetDiscardRectangleEXT;
+ }
+#endif
+#ifdef VK_EXT_hdr_metadata
+ if (!strcmp(name, "vkSetHdrMetadataEXT"))
+ {
+ return (void*)entry_vkSetHdrMetadataEXT;
+ }
+#endif
+#ifdef VK_MVK_ios_surface
+ if (!strcmp(name, "vkCreateIOSSurfaceMVK"))
+ {
+ return (void*)entry_vkCreateIOSSurfaceMVK;
+ }
+#endif
+#ifdef VK_MVK_macos_surface
+ if (!strcmp(name, "vkCreateMacOSSurfaceMVK"))
+ {
+ return (void*)entry_vkCreateMacOSSurfaceMVK;
+ }
+#endif
+#ifdef VK_EXT_debug_utils
+ if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT"))
+ {
+ return (void*)entry_vkSetDebugUtilsObjectNameEXT;
+ }
+ if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT"))
+ {
+ return (void*)entry_vkSetDebugUtilsObjectTagEXT;
+ }
+ if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkQueueBeginDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkQueueEndDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkQueueInsertDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkCmdBeginDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkCmdEndDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkCmdInsertDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT"))
+ {
+ return (void*)entry_vkCreateDebugUtilsMessengerEXT;
+ }
+ if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT"))
+ {
+ return (void*)entry_vkDestroyDebugUtilsMessengerEXT;
+ }
+ if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT"))
+ {
+ return (void*)entry_vkSubmitDebugUtilsMessageEXT;
+ }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+ if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID"))
+ {
+ return (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID;
+ }
+ if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID"))
+ {
+ return (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID;
+ }
+#endif
+#ifdef VK_EXT_sample_locations
+ if (!strcmp(name, "vkCmdSetSampleLocationsEXT"))
+ {
+ return (void*)entry_vkCmdSetSampleLocationsEXT;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMultisamplePropertiesEXT;
+ }
+#endif
+#ifdef VK_EXT_validation_cache
+ if (!strcmp(name, "vkCreateValidationCacheEXT"))
+ {
+ return (void*)entry_vkCreateValidationCacheEXT;
+ }
+ if (!strcmp(name, "vkDestroyValidationCacheEXT"))
+ {
+ return (void*)entry_vkDestroyValidationCacheEXT;
+ }
+ if (!strcmp(name, "vkMergeValidationCachesEXT"))
+ {
+ return (void*)entry_vkMergeValidationCachesEXT;
+ }
+ if (!strcmp(name, "vkGetValidationCacheDataEXT"))
+ {
+ return (void*)entry_vkGetValidationCacheDataEXT;
+ }
+#endif
+#ifdef VK_EXT_external_memory_host
+ if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT"))
+ {
+ return (void*)entry_vkGetMemoryHostPointerPropertiesEXT;
+ }
+#endif
+#ifdef VK_AMD_buffer_marker
+ if (!strcmp(name, "vkCmdWriteBufferMarkerAMD"))
+ {
+ return (void*)entry_vkCmdWriteBufferMarkerAMD;
+ }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+ if (!strcmp(name, "vkCmdSetCheckpointNV"))
+ {
+ return (void*)entry_vkCmdSetCheckpointNV;
+ }
+ if (!strcmp(name, "vkGetQueueCheckpointDataNV"))
+ {
+ return (void*)entry_vkGetQueueCheckpointDataNV;
+ }
+#endif
+ return nullptr;
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan/func_table.h b/system/vulkan/func_table.h
new file mode 100644
index 0000000..358eec4
--- /dev/null
+++ b/system/vulkan/func_table.h
@@ -0,0 +1,281 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module func_table
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+#endif
+#ifdef VK_VERSION_1_1
+#endif
+#ifdef VK_KHR_surface
+#endif
+#ifdef VK_KHR_swapchain
+#endif
+#ifdef VK_KHR_display
+#endif
+#ifdef VK_KHR_display_swapchain
+#endif
+#ifdef VK_KHR_xlib_surface
+#endif
+#ifdef VK_KHR_xcb_surface
+#endif
+#ifdef VK_KHR_wayland_surface
+#endif
+#ifdef VK_KHR_mir_surface
+#endif
+#ifdef VK_KHR_android_surface
+#endif
+#ifdef VK_KHR_win32_surface
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+#endif
+#ifdef VK_KHR_external_memory_fd
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+#endif
+#ifdef VK_KHR_push_descriptor
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+#endif
+#ifdef VK_KHR_shared_presentable_image
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+#endif
+#ifdef VK_KHR_external_fence_fd
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+#endif
+#ifdef VK_EXT_debug_report
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+#endif
+#ifdef VK_NVX_device_generated_commands
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+#endif
+#ifdef VK_EXT_display_control
+#endif
+#ifdef VK_GOOGLE_display_timing
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+#endif
+#ifdef VK_MVK_ios_surface
+#endif
+#ifdef VK_MVK_macos_surface
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+#endif
+void* goldfish_vulkan_get_proc_address(const char* name);
+
+} // namespace goldfish_vk
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
new file mode 100644
index 0000000..537c966
--- /dev/null
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -0,0 +1,148 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <hardware/hwvulkan.h>
+
+#include <log/log.h>
+
+#include <errno.h>
+#include <string.h>
+
+#include "HostConnection.h"
+#include "ResourceTracker.h"
+#include "VkEncoder.h"
+
+#include "func_table.h"
+
+namespace {
+
+int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device);
+
+hw_module_methods_t goldfish_vulkan_module_methods = {
+ .open = OpenDevice
+};
+
+extern "C" __attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
+ .common = {
+ .tag = HARDWARE_MODULE_TAG,
+ .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
+ .hal_api_version = HARDWARE_HAL_API_VERSION,
+ .id = HWVULKAN_HARDWARE_MODULE_ID,
+ .name = "Goldfish Vulkan Driver",
+ .author = "The Android Open Source Project",
+ .methods = &goldfish_vulkan_module_methods,
+ },
+};
+
+int CloseDevice(struct hw_device_t* /*device*/) {
+ // nothing to do - opening a device doesn't allocate any resources
+ return 0;
+}
+
+#define VK_HOST_CONNECTION \
+ HostConnection *hostCon = HostConnection::get(); \
+ if (!hostCon) { \
+ ALOGE("vulkan: Failed to get host connection\n"); \
+ return VK_ERROR_DEVICE_LOST; \
+ } \
+ ExtendedRCEncoderContext *rcEnc = hostCon->rcEncoder(); \
+ if (!rcEnc) { \
+ ALOGE("vulkan: Failed to get renderControl encoder context\n"); \
+ return VK_ERROR_DEVICE_LOST; \
+ } \
+ goldfish_vk::VkEncoder *vkEnc = hostCon->vkEncoder(); \
+ if (!vkEnc) { \
+ ALOGE("vulkan: Failed to get Vulkan encoder\n"); \
+ return VK_ERROR_DEVICE_LOST; \
+ } \
+
+VKAPI_ATTR
+VkResult EnumerateInstanceExtensionProperties(
+ const char* layer_name,
+ uint32_t* count,
+ VkExtensionProperties* properties) {
+
+ VK_HOST_CONNECTION;
+
+ if (layer_name) {
+ ALOGW(
+ "Driver vkEnumerateInstanceExtensionProperties shouldn't be called "
+ "with a layer name ('%s')",
+ layer_name);
+ }
+
+ // For now, let's not expose any extensions;
+ // add them one at a time as needed.
+ *count = 0;
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR
+VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkInstance* out_instance) {
+ ALOGD("%s: goldfish vkCreateInstance\n", __func__);
+ VK_HOST_CONNECTION;
+
+ VkResult res = vkEnc->vkCreateInstance(create_info, nullptr, out_instance);
+
+ return res;
+}
+
+static PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
+ if (!strcmp(name, "vkGetDeviceProcAddr")) {
+ return (PFN_vkVoidFunction)(GetDeviceProcAddr);
+ }
+ return (PFN_vkVoidFunction)(goldfish_vk::goldfish_vulkan_get_proc_address(name));
+}
+
+VKAPI_ATTR
+PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
+ (void)instance;
+ if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
+ return (PFN_vkVoidFunction)EnumerateInstanceExtensionProperties;
+ }
+ if (!strcmp(name, "vkCreateInstance")) {
+ return (PFN_vkVoidFunction)CreateInstance;
+ }
+ if (!strcmp(name, "vkGetDeviceProcAddr")) {
+ return (PFN_vkVoidFunction)(GetDeviceProcAddr);
+ }
+ return (PFN_vkVoidFunction)(goldfish_vk::goldfish_vulkan_get_proc_address(name));
+}
+
+hwvulkan_device_t goldfish_vulkan_device = {
+ .common = {
+ .tag = HARDWARE_DEVICE_TAG,
+ .version = HWVULKAN_DEVICE_API_VERSION_0_1,
+ .module = &HAL_MODULE_INFO_SYM.common,
+ .close = CloseDevice,
+ },
+ .EnumerateInstanceExtensionProperties = EnumerateInstanceExtensionProperties,
+ .CreateInstance = CreateInstance,
+ .GetInstanceProcAddr = GetInstanceProcAddr,
+};
+
+int OpenDevice(const hw_module_t* /*module*/,
+ const char* id,
+ hw_device_t** device) {
+ if (strcmp(id, HWVULKAN_DEVICE_0) == 0) {
+ *device = &goldfish_vulkan_device.common;
+ goldfish_vk::ResourceTracker::get();
+ return 0;
+ }
+ return -ENOENT;
+}
+
+} // namespace
diff --git a/system/vulkan_enc/Android.mk b/system/vulkan_enc/Android.mk
new file mode 100644
index 0000000..7a146dc
--- /dev/null
+++ b/system/vulkan_enc/Android.mk
@@ -0,0 +1,64 @@
+
+# Autogenerated makefile
+# android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+# Please do not modify directly;
+# re-run android/scripts/generate-vulkan-sources.sh,
+# or directly from Python by defining:
+# VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+# CEREAL_OUTPUT_DIR: Where to put the generated sources.
+# python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+LOCAL_PATH := $(call my-dir)
+
+$(call emugl-begin-shared-library,libvulkan_enc)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
+$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX) libandroidemu)
+
+# Vulkan include dir
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+LOCAL_C_INCLUDES += \
+ $(LOCAL_PATH) \
+ $(HOST_EMUGL_PATH)/host/include \
+ $(HOST_EMUGL_PATH)/host/include/vulkan
+endif
+
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+LOCAL_C_INCLUDES += \
+ $(LOCAL_PATH) \
+ $(LOCAL_PATH)/../vulkan_enc \
+
+LOCAL_HEADER_LIBRARIES += \
+ vulkan_headers \
+
+endif
+
+LOCAL_CFLAGS += \
+ -DLOG_TAG=\"goldfish_vulkan\" \
+ -DVK_ANDROID_native_buffer \
+ -Wno-missing-field-initializers \
+ -Werror \
+ -fstrict-aliasing \
+ -DVK_USE_PLATFORM_ANDROID_KHR \
+ -DVK_NO_PROTOTYPES \
+
+LOCAL_SRC_FILES := Resources.cpp \
+ Validation.cpp \
+ VulkanStream.cpp \
+ VulkanHandleMapping.cpp \
+ ResourceTracker.cpp \
+ VkEncoder.cpp \
+VkEventHandler.cpp \
+goldfish_vk_extension_structs_guest.cpp \
+goldfish_vk_marshaling_guest.cpp \
+goldfish_vk_deepcopy_guest.cpp \
+goldfish_vk_handlemap_guest.cpp \
+
+
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+$(call emugl-export,SHARED_LIBRARIES,libgui)
+else
+$(call emugl-export,SHARED_LIBRARIES,libsync)
+endif
+
+$(call emugl-end-module)
+
diff --git a/system/vulkan_enc/CMakeLists.txt b/system/vulkan_enc/CMakeLists.txt
new file mode 100644
index 0000000..0f43f29
--- /dev/null
+++ b/system/vulkan_enc/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc/Android.mk" "aad370b1675d05b89d55d471376175c21c2d4567f65a593dabe3038f8806219c")
+set(vulkan_enc_src Resources.cpp Validation.cpp VulkanStream.cpp VulkanHandleMapping.cpp ResourceTracker.cpp VkEncoder.cpp VkEventHandler.cpp goldfish_vk_extension_structs_guest.cpp goldfish_vk_marshaling_guest.cpp goldfish_vk_deepcopy_guest.cpp goldfish_vk_handlemap_guest.cpp)
+android_add_shared_library(vulkan_enc)
+target_include_directories(vulkan_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include/vulkan)
+target_compile_definitions(vulkan_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_ANDROID_native_buffer" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES")
+target_compile_options(vulkan_enc PRIVATE "-fvisibility=default" "-Wno-missing-field-initializers" "-Werror" "-fstrict-aliasing")
+target_link_libraries(vulkan_enc PRIVATE gui cutils utils log OpenglCodecCommon_host android-emu-shared)
\ No newline at end of file
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
new file mode 100644
index 0000000..4def37d
--- /dev/null
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -0,0 +1,204 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ResourceTracker.h"
+
+#include "Resources.h"
+
+#include "android/base/synchronization/AndroidLock.h"
+
+#include <unordered_map>
+
+using android::base::guest::AutoLock;
+using android::base::guest::Lock;
+
+namespace goldfish_vk {
+
+#define MAKE_HANDLE_MAPPING_FOREACH(type_name, map_impl, map_to_u64_impl, map_from_u64_impl) \
+ void mapHandles_##type_name(type_name* handles, size_t count) override { \
+ for (size_t i = 0; i < count; ++i) { \
+ map_impl; \
+ } \
+ } \
+ void mapHandles_##type_name##_u64(const type_name* handles, uint64_t* handle_u64s, size_t count) override { \
+ for (size_t i = 0; i < count; ++i) { \
+ map_to_u64_impl; \
+ } \
+ } \
+ void mapHandles_u64_##type_name(const uint64_t* handle_u64s, type_name* handles, size_t count) override { \
+ for (size_t i = 0; i < count; ++i) { \
+ map_from_u64_impl; \
+ } \
+ } \
+
+#define DEFINE_RESOURCE_TRACKING_CLASS(class_name, impl) \
+class class_name : public VulkanHandleMapping { \
+public: \
+ virtual ~class_name() { } \
+ GOLDFISH_VK_LIST_HANDLE_TYPES(impl) \
+}; \
+
+#define CREATE_MAPPING_IMPL_FOR_TYPE(type_name) \
+ MAKE_HANDLE_MAPPING_FOREACH(type_name, \
+ handles[i] = new_from_host_##type_name(handles[i]); ResourceTracker::get()->register_##type_name(handles[i]);, \
+ handle_u64s[i] = (uint64_t)(uintptr_t)new_from_host_##type_name(handles[i]), \
+ handles[i] = (type_name)(uintptr_t)new_from_host_u64_##type_name(handle_u64s[i]); ResourceTracker::get()->register_##type_name(handles[i]);)
+
+#define UNWRAP_MAPPING_IMPL_FOR_TYPE(type_name) \
+ MAKE_HANDLE_MAPPING_FOREACH(type_name, \
+ handles[i] = get_host_##type_name(handles[i]), \
+ handle_u64s[i] = (uint64_t)(uintptr_t)get_host_u64_##type_name(handles[i]), \
+ handles[i] = (type_name)(uintptr_t)get_host_##type_name((type_name)(uintptr_t)handle_u64s[i]))
+
+#define DESTROY_MAPPING_IMPL_FOR_TYPE(type_name) \
+ MAKE_HANDLE_MAPPING_FOREACH(type_name, \
+ ResourceTracker::get()->unregister_##type_name(handles[i]); delete_goldfish_##type_name(handles[i]), \
+ (void)handle_u64s[i]; delete_goldfish_##type_name(handles[i]), \
+ (void)handles[i]; delete_goldfish_##type_name((type_name)(uintptr_t)handle_u64s[i]))
+
+DEFINE_RESOURCE_TRACKING_CLASS(CreateMapping, CREATE_MAPPING_IMPL_FOR_TYPE)
+DEFINE_RESOURCE_TRACKING_CLASS(UnwrapMapping, UNWRAP_MAPPING_IMPL_FOR_TYPE)
+DEFINE_RESOURCE_TRACKING_CLASS(DestroyMapping, DESTROY_MAPPING_IMPL_FOR_TYPE)
+
+class ResourceTracker::Impl {
+public:
+ Impl() = default;
+ CreateMapping createMapping;
+ UnwrapMapping unwrapMapping;
+ DestroyMapping destroyMapping;
+ DefaultHandleMapping defaultMapping;
+
+#define HANDLE_DEFINE_TRIVIAL_INFO_STRUCT(type) \
+ struct type##_Info { \
+ uint32_t unused; \
+ }; \
+
+ GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(HANDLE_DEFINE_TRIVIAL_INFO_STRUCT)
+
+ struct VkDevice_Info {
+ VkPhysicalDevice physdev;
+ VkPhysicalDeviceProperties props;
+ VkPhysicalDeviceMemoryProperties memProps;
+ };
+
+ struct VkDeviceMemory_Info {
+ VkDeviceSize allocationSize;
+ uint32_t memoryTypeIndex;
+ };
+
+#define HANDLE_REGISTER_IMPL_IMPL(type) \
+ std::unordered_map<type, type##_Info> info_##type; \
+ void register_##type(type obj) { \
+ AutoLock lock(mLock); \
+ info_##type[obj] = type##_Info(); \
+ } \
+ void unregister_##type(type obj) { \
+ AutoLock lock(mLock); \
+ info_##type.erase(obj); \
+ } \
+
+ GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_IMPL_IMPL)
+
+ void setDeviceInfo(VkDevice device,
+ VkPhysicalDevice physdev,
+ VkPhysicalDeviceProperties props,
+ VkPhysicalDeviceMemoryProperties memProps) {
+ AutoLock lock(mLock);
+ auto& info = info_VkDevice[device];
+ info.physdev = physdev;
+ info.props = props;
+ info.memProps = memProps;
+ }
+
+ bool isMemoryTypeHostVisible(VkDevice device, uint32_t typeIndex) const {
+ AutoLock lock(mLock);
+ const auto it = info_VkDevice.find(device);
+
+ if (it == info_VkDevice.end()) return false;
+
+ const auto& info = it->second;
+ return info.memProps.memoryTypes[typeIndex].propertyFlags &
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+ }
+
+ VkDeviceSize getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
+ AutoLock lock(mLock);
+ const auto it = info_VkDevice.find(device);
+ if (it == info_VkDevice.end()) return basicSize;
+ const auto& info = it->second;
+
+ VkDeviceSize nonCoherentAtomSize =
+ info.props.limits.nonCoherentAtomSize;
+ VkDeviceSize atoms =
+ (basicSize + nonCoherentAtomSize - 1) / nonCoherentAtomSize;
+ return atoms * nonCoherentAtomSize;
+ }
+
+private:
+ mutable Lock mLock;
+
+};
+ResourceTracker::ResourceTracker() : mImpl(new ResourceTracker::Impl()) { }
+ResourceTracker::~ResourceTracker() { }
+VulkanHandleMapping* ResourceTracker::createMapping() {
+ return &mImpl->createMapping;
+}
+VulkanHandleMapping* ResourceTracker::unwrapMapping() {
+ return &mImpl->unwrapMapping;
+}
+VulkanHandleMapping* ResourceTracker::destroyMapping() {
+ return &mImpl->destroyMapping;
+}
+VulkanHandleMapping* ResourceTracker::defaultMapping() {
+ return &mImpl->defaultMapping;
+}
+static ResourceTracker* sTracker = nullptr;
+// static
+ResourceTracker* ResourceTracker::get() {
+ if (!sTracker) {
+ // To be initialized once on vulkan device open.
+ sTracker = new ResourceTracker;
+ }
+ return sTracker;
+}
+
+#define HANDLE_REGISTER_IMPL(type) \
+ void ResourceTracker::register_##type(type obj) { \
+ mImpl->register_##type(obj); \
+ } \
+ void ResourceTracker::unregister_##type(type obj) { \
+ mImpl->unregister_##type(obj); \
+ } \
+
+GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_IMPL)
+
+void ResourceTracker::setDeviceInfo(
+ VkDevice device,
+ VkPhysicalDevice physdev,
+ VkPhysicalDeviceProperties props,
+ VkPhysicalDeviceMemoryProperties memProps) {
+ mImpl->setDeviceInfo(device, physdev, props, memProps);
+}
+
+bool ResourceTracker::isMemoryTypeHostVisible(
+ VkDevice device, uint32_t typeIndex) const {
+ return mImpl->isMemoryTypeHostVisible(device, typeIndex);
+}
+
+VkDeviceSize ResourceTracker::getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
+ return mImpl->getNonCoherentExtendedSize(device, basicSize);
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/ResourceTracker.h b/system/vulkan_enc/ResourceTracker.h
new file mode 100644
index 0000000..e40e413
--- /dev/null
+++ b/system/vulkan_enc/ResourceTracker.h
@@ -0,0 +1,53 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#include "VulkanHandleMapping.h"
+#include "VulkanHandles.h"
+#include "VkEventHandler.h"
+#include <memory>
+
+namespace goldfish_vk {
+
+class ResourceTracker : public VkEventHandler {
+public:
+ ResourceTracker();
+ virtual ~ResourceTracker();
+ static ResourceTracker* get();
+ VulkanHandleMapping* createMapping();
+ VulkanHandleMapping* unwrapMapping();
+ VulkanHandleMapping* destroyMapping();
+ VulkanHandleMapping* defaultMapping();
+
+#define HANDLE_REGISTER_DECL(type) \
+ void register_##type(type); \
+ void unregister_##type(type); \
+
+ GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_DECL)
+
+ void setDeviceInfo(VkDevice device, VkPhysicalDevice physdev, VkPhysicalDeviceProperties props, VkPhysicalDeviceMemoryProperties memProps);
+ bool isMemoryTypeHostVisible(VkDevice device, uint32_t typeIndex) const;
+ VkDeviceSize getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const;
+ bool isValidMemoryRange(
+ VkDevice device,
+ const VkMappedMemoryRange& range) const;
+ private:
+ class Impl;
+ std::unique_ptr<Impl> mImpl;
+};
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/Resources.cpp b/system/vulkan_enc/Resources.cpp
new file mode 100644
index 0000000..c2b972e
--- /dev/null
+++ b/system/vulkan_enc/Resources.cpp
@@ -0,0 +1,338 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "Resources.h"
+#include "ResourceTracker.h"
+#include "VkEncoder.h"
+
+#include "gralloc_cb.h"
+#include "goldfish_vk_private_defs.h"
+
+#include "android/base/AlignedBuf.h"
+
+#include <log/log.h>
+#include <stdlib.h>
+#include <sync/sync.h>
+
+using android::aligned_buf_alloc;
+using android::aligned_buf_free;
+
+#define GOLDFISH_VK_OBJECT_DEBUG 0
+
+#if GOLDFISH_VK_OBJECT_DEBUG
+#define D(fmt,...) ALOGD("%s: " fmt, __func__, ##__VA_ARGS__);
+#else
+#ifndef D
+#define D(fmt,...)
+#endif
+#endif
+
+using goldfish_vk::ResourceTracker;
+using goldfish_vk::VkEncoder;
+
+extern "C" {
+
+#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL(type) \
+ type new_from_host_##type(type underlying) { \
+ struct goldfish_##type* res = \
+ static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+ if (!res) { \
+ ALOGE("FATAL: Failed to alloc " #type " handle"); \
+ abort(); \
+ } \
+ res->dispatch.magic = HWVULKAN_DISPATCH_MAGIC; \
+ res->underlying = (uint64_t)(uintptr_t)underlying; \
+ return reinterpret_cast<type>(res); \
+ } \
+
+#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL(type) \
+ type new_from_host_##type(type underlying) { \
+ struct goldfish_##type* res = \
+ static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+ res->underlying = (uint64_t)(uintptr_t)underlying; \
+ return reinterpret_cast<type>(res); \
+ } \
+
+#define GOLDFISH_VK_AS_GOLDFISH_IMPL(type) \
+ struct goldfish_##type* as_goldfish_##type(type toCast) { \
+ return reinterpret_cast<goldfish_##type*>(toCast); \
+ } \
+
+#define GOLDFISH_VK_GET_HOST_IMPL(type) \
+ type get_host_##type(type toUnwrap) { \
+ if (!toUnwrap) return VK_NULL_HANDLE; \
+ auto as_goldfish = as_goldfish_##type(toUnwrap); \
+ return (type)(uintptr_t)(as_goldfish->underlying); \
+ } \
+
+#define GOLDFISH_VK_DELETE_GOLDFISH_IMPL(type) \
+ void delete_goldfish_##type(type toDelete) { \
+ D("guest %p", toDelete); \
+ free(as_goldfish_##type(toDelete)); \
+ } \
+
+#define GOLDFISH_VK_IDENTITY_IMPL(type) \
+ type vk_handle_identity_##type(type handle) { \
+ return handle; \
+ } \
+
+#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
+ type new_from_host_u64_##type(uint64_t underlying) { \
+ struct goldfish_##type* res = \
+ static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+ if (!res) { \
+ ALOGE("FATAL: Failed to alloc " #type " handle"); \
+ abort(); \
+ } \
+ res->dispatch.magic = HWVULKAN_DISPATCH_MAGIC; \
+ res->underlying = underlying; \
+ return reinterpret_cast<type>(res); \
+ } \
+
+#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
+ type new_from_host_u64_##type(uint64_t underlying) { \
+ struct goldfish_##type* res = \
+ static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
+ res->underlying = underlying; \
+ D("guest %p: host u64: 0x%llx", res, (unsigned long long)res->underlying); \
+ return reinterpret_cast<type>(res); \
+ } \
+
+#define GOLDFISH_VK_GET_HOST_U64_IMPL(type) \
+ uint64_t get_host_u64_##type(type toUnwrap) { \
+ if (!toUnwrap) return 0; \
+ auto as_goldfish = as_goldfish_##type(toUnwrap); \
+ D("guest %p: host u64: 0x%llx", toUnwrap, (unsigned long long)as_goldfish->underlying); \
+ return as_goldfish->underlying; \
+ } \
+
+
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_U64_IMPL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_IMPL)
+
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_IMPL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_IMPL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_IMPL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_IMPL)
+
+GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL)
+GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL)
+GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_IMPL)
+
+// Custom definitions///////////////////////////////////////////////////////////
+
+VkResult goldfish_vkEnumerateInstanceVersion(
+ void*,
+ VkResult,
+ uint32_t* apiVersion) {
+ if (apiVersion) {
+ *apiVersion = VK_MAKE_VERSION(1, 0, 0);
+ }
+ return VK_SUCCESS;
+}
+
+VkResult goldfish_vkEnumerateDeviceExtensionProperties(
+ void*,
+ VkResult,
+ VkPhysicalDevice, const char*,
+ uint32_t *pPropertyCount, VkExtensionProperties *) {
+ *pPropertyCount = 0;
+ return VK_SUCCESS;
+}
+
+void goldfish_vkGetPhysicalDeviceProperties2(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceProperties2*)
+{
+ // no-op
+}
+
+VkResult goldfish_vkCreateDevice(
+ void* opaque,
+ VkResult host_return,
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDevice* pDevice) {
+
+ if (host_return != VK_SUCCESS) return host_return;
+
+ VkEncoder* enc = (VkEncoder*)opaque;
+
+ VkPhysicalDeviceProperties props;
+ VkPhysicalDeviceMemoryProperties memProps;
+ enc->vkGetPhysicalDeviceProperties(physicalDevice, &props);
+ enc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProps);
+
+ ResourceTracker::get()->setDeviceInfo(*pDevice, physicalDevice, props, memProps);
+
+ return host_return;
+}
+
+VkDeviceMemory new_from_host_VkDeviceMemory(VkDeviceMemory mem) {
+ struct goldfish_VkDeviceMemory *res =
+ (struct goldfish_VkDeviceMemory *)malloc(sizeof(goldfish_VkDeviceMemory));
+
+ if (!res) {
+ ALOGE("FATAL: Failed to alloc VkDeviceMemory handle");
+ abort();
+ }
+
+ memset(res, 0x0, sizeof(goldfish_VkDeviceMemory));
+
+ res->underlying = (uint64_t)(uintptr_t)mem;
+
+ return reinterpret_cast<VkDeviceMemory>(res);
+}
+
+VkDeviceMemory new_from_host_u64_VkDeviceMemory(uint64_t mem) {
+ struct goldfish_VkDeviceMemory *res =
+ (struct goldfish_VkDeviceMemory *)malloc(sizeof(goldfish_VkDeviceMemory));
+
+ if (!res) {
+ ALOGE("FATAL: Failed to alloc VkDeviceMemory handle");
+ abort();
+ }
+
+ memset(res, 0x0, sizeof(goldfish_VkDeviceMemory));
+
+ res->underlying = mem;
+
+ return reinterpret_cast<VkDeviceMemory>(res);
+}
+
+void delete_goldfish_VkDeviceMemory(VkDeviceMemory mem) {
+ struct goldfish_VkDeviceMemory* goldfish_mem =
+ as_goldfish_VkDeviceMemory(mem);
+
+ if (!goldfish_mem) return;
+
+ if (goldfish_mem->ptr) {
+ // TODO: unmap the pointer with address space device
+ aligned_buf_free(goldfish_mem->ptr);
+ }
+
+ free(goldfish_mem);
+}
+
+VkResult goldfish_vkAllocateMemory(
+ void*,
+ VkResult host_return,
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks*,
+ VkDeviceMemory* pMemory) {
+
+ if (host_return != VK_SUCCESS) return host_return;
+
+ // Assumes pMemory has already been allocated.
+ goldfish_VkDeviceMemory* mem = as_goldfish_VkDeviceMemory(*pMemory);
+ VkDeviceSize size = pAllocateInfo->allocationSize;
+
+ // assume memory is not host visible.
+ mem->ptr = nullptr;
+ mem->size = size;
+ mem->mappedSize = ResourceTracker::get()->getNonCoherentExtendedSize(device, size);
+
+ if (!ResourceTracker::get()->isMemoryTypeHostVisible(device, pAllocateInfo->memoryTypeIndex)) {
+ return host_return;
+ }
+
+ // This is a strict alignment; we do not expect any
+ // actual device to have more stringent requirements
+ // than this.
+ mem->ptr = (uint8_t*)aligned_buf_alloc(4096, mem->mappedSize);
+ D("host visible alloc: size 0x%llx host ptr %p mapped size 0x%llx",
+ (unsigned long long)size, mem->ptr,
+ (unsigned long long)mem->mappedSize);
+
+ return host_return;
+}
+
+VkResult goldfish_vkMapMemory(
+ void*,
+ VkResult host_result,
+ VkDevice,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags,
+ void** ppData) {
+
+ if (host_result != VK_SUCCESS) return host_result;
+
+ goldfish_VkDeviceMemory* mem = as_goldfish_VkDeviceMemory(memory);
+
+ if (!mem->ptr) {
+ return VK_ERROR_MEMORY_MAP_FAILED;
+ }
+
+ if (size != VK_WHOLE_SIZE &&
+ (mem->ptr + offset + size > mem->ptr + mem->size)) {
+ return VK_ERROR_MEMORY_MAP_FAILED;
+ }
+
+ *ppData = mem->ptr + offset;
+
+ return host_result;
+}
+
+void goldfish_vkUnmapMemory(
+ void*,
+ VkDevice,
+ VkDeviceMemory) {
+ // no-op
+}
+
+void goldfish_unwrap_VkNativeBufferANDROID(
+ const VkImageCreateInfo* pCreateInfo,
+ VkImageCreateInfo* local_pCreateInfo) {
+
+ if (!pCreateInfo->pNext) return;
+
+ const VkNativeBufferANDROID* nativeInfo =
+ reinterpret_cast<const VkNativeBufferANDROID*>(pCreateInfo->pNext);
+
+ if (VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID != nativeInfo->sType) {
+ return;
+ }
+
+ const cb_handle_t* cb_handle =
+ reinterpret_cast<const cb_handle_t*>(nativeInfo->handle);
+
+ if (!cb_handle) return;
+
+ VkNativeBufferANDROID* nativeInfoOut =
+ reinterpret_cast<VkNativeBufferANDROID*>(local_pCreateInfo);
+
+ if (!nativeInfoOut->handle) {
+ ALOGE("FATAL: Local native buffer info not properly allocated!");
+ abort();
+ }
+
+ *(uint32_t*)(nativeInfoOut->handle) = cb_handle->hostHandle;
+}
+
+void goldfish_unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int*) {
+ if (fd != -1) {
+ sync_wait(fd, 3000);
+ }
+}
+
+} // extern "C"
diff --git a/system/vulkan_enc/Resources.h b/system/vulkan_enc/Resources.h
new file mode 100644
index 0000000..37cd882
--- /dev/null
+++ b/system/vulkan_enc/Resources.h
@@ -0,0 +1,138 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <hardware/hwvulkan.h>
+#include <vulkan/vulkan.h>
+
+#include "VulkanHandles.h"
+
+#include <inttypes.h>
+
+extern "C" {
+
+#define GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT(type) \
+ struct goldfish_##type { \
+ hwvulkan_dispatch_t dispatch; \
+ uint64_t underlying; \
+ }; \
+
+#define GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT(type) \
+ struct goldfish_##type { \
+ uint64_t underlying; \
+ }; \
+
+#define GOLDFISH_VK_NEW_FROM_HOST_DECL(type) \
+ type new_from_host_##type(type);
+
+#define GOLDFISH_VK_AS_GOLDFISH_DECL(type) \
+ struct goldfish_##type* as_goldfish_##type(type);
+
+#define GOLDFISH_VK_GET_HOST_DECL(type) \
+ type get_host_##type(type);
+
+#define GOLDFISH_VK_DELETE_GOLDFISH_DECL(type) \
+ void delete_goldfish_##type(type);
+
+#define GOLDFISH_VK_IDENTITY_DECL(type) \
+ type vk_handle_identity_##type(type);
+
+#define GOLDFISH_VK_NEW_FROM_HOST_U64_DECL(type) \
+ type new_from_host_u64_##type(uint64_t);
+
+#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_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)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_U64_DECL)
+GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_DECL)
+
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_U64_DECL)
+GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_DECL)
+
+GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT)
+
+// Custom definitions///////////////////////////////////////////////////////////
+
+VkResult goldfish_vkEnumerateInstanceVersion(
+ void* opaque,
+ VkResult host_return,
+ uint32_t* apiVersion);
+
+VkResult goldfish_vkEnumerateDeviceExtensionProperties(
+ void* opaque,
+ VkResult host_return,
+ VkPhysicalDevice physicalDevice, const char *pLayerName,
+ uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
+
+void goldfish_vkGetPhysicalDeviceProperties2(
+ void* opaque,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties);
+
+VkResult goldfish_vkCreateDevice(
+ void* opaque,
+ VkResult host_return,
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+
+struct goldfish_VkDeviceMemory {
+ uint64_t underlying;
+ uint8_t* ptr;
+ VkDeviceSize size;
+ VkDeviceSize mappedSize;
+};
+
+VkResult goldfish_vkAllocateMemory(
+ void* opaque,
+ VkResult host_return,
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory);
+
+VkResult goldfish_vkMapMemory(
+ void* opaque,
+ VkResult host_return,
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData);
+
+void goldfish_vkUnmapMemory(
+ void* opaque,
+ VkDevice device,
+ VkDeviceMemory memory);
+
+void goldfish_unwrap_VkNativeBufferANDROID(
+ const VkImageCreateInfo* pCreateInfo,
+ VkImageCreateInfo* local_pCreateInfo);
+
+void goldfish_unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int* fd_out);
+
+} // extern "C"
diff --git a/system/vulkan_enc/Validation.cpp b/system/vulkan_enc/Validation.cpp
new file mode 100644
index 0000000..7653f76
--- /dev/null
+++ b/system/vulkan_enc/Validation.cpp
@@ -0,0 +1,70 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "Validation.h"
+
+#include "Resources.h"
+
+namespace goldfish_vk {
+
+static bool is_range_good(const VkMappedMemoryRange& range) {
+ const goldfish_VkDeviceMemory* mem =
+ as_goldfish_VkDeviceMemory(range.memory);
+
+ if (!mem || !mem->ptr) {
+ return false;
+ }
+
+ VkDeviceSize offset = range.offset;
+ VkDeviceSize size = range.size;
+
+ if (size == VK_WHOLE_SIZE) {
+ return offset <= mem->mappedSize;
+ };
+
+ return offset + size <= mem->mappedSize;
+}
+
+VkResult Validation::on_vkFlushMappedMemoryRanges(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
+
+ for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+ if (!is_range_good(pMemoryRanges[i])) {
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+ }
+
+ return VK_SUCCESS;
+}
+
+VkResult Validation::on_vkInvalidateMappedMemoryRanges(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
+
+ for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+ if (!is_range_good(pMemoryRanges[i])) {
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+ }
+
+ return VK_SUCCESS;
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/Validation.h b/system/vulkan_enc/Validation.h
new file mode 100644
index 0000000..30af8b4
--- /dev/null
+++ b/system/vulkan_enc/Validation.h
@@ -0,0 +1,38 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#include "VkEventHandler.h"
+
+namespace goldfish_vk {
+
+class Validation : public VkEventHandler {
+public:
+ VkResult on_vkFlushMappedMemoryRanges(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) override;
+ VkResult on_vkInvalidateMappedMemoryRanges(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) override;
+};
+
+} // namespace goldfish_vk
\ No newline at end of file
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
new file mode 100644
index 0000000..87745f4
--- /dev/null
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -0,0 +1,18960 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module VkEncoder
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "VkEncoder.h"
+
+
+#include "IOStream.h"
+#include "Resources.h"
+#include "ResourceTracker.h"
+#include "Validation.h"
+#include "VulkanStream.h"
+
+#include "android/base/AlignedBuf.h"
+#include "android/base/Pool.h"
+
+#include "goldfish_vk_marshaling_guest.h"
+#include "goldfish_vk_deepcopy_guest.h"
+#include "goldfish_vk_handlemap_guest.h"
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+
+
+using namespace goldfish_vk;
+
+using android::aligned_buf_alloc;
+using android::aligned_buf_free;
+using android::base::Pool;
+
+class VkEncoder::Impl {
+public:
+ Impl(IOStream* stream) : m_stream(stream) { }
+ VulkanCountingStream* countingStream() { return &m_countingStream; }
+ VulkanStream* stream() { return &m_stream; }
+ Pool* pool() { return &m_pool; }
+ ResourceTracker* resources() { return ResourceTracker::get(); }
+ Validation* validation() { return &m_validation; }
+private:
+ VulkanCountingStream m_countingStream;
+ VulkanStream m_stream;
+ Pool m_pool { 8, 4096, 64 };
+
+ Validation m_validation;
+};
+
+VkEncoder::VkEncoder(IOStream *stream) :
+ mImpl(new VkEncoder::Impl(stream)) { }
+
+#define VALIDATE_RET(retType, success, validate) \
+ retType goldfish_vk_validateResult = validate; \
+ if (goldfish_vk_validateResult != success) return goldfish_vk_validateResult; \
+
+#define VALIDATE_VOID(validate) \
+ VkResult goldfish_vk_validateResult = validate; \
+ if (goldfish_vk_validateResult != VK_SUCCESS) return; \
+
+#ifdef VK_VERSION_1_0
+VkResult VkEncoder::vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstanceCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkInstanceCreateInfo*)pool->alloc(sizeof(const VkInstanceCreateInfo));
+ deepcopy_VkInstanceCreateInfo(pool, pCreateInfo, (VkInstanceCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ marshal_VkInstanceCreateInfo(countingStream, (VkInstanceCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_0);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(pInstance, &cgen_var_1, 1);
+ countingStream->write((uint64_t*)&cgen_var_1, 8);
+ }
+ uint32_t packetSize_vkCreateInstance = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateInstance = OP_vkCreateInstance;
+ stream->write(&opcode_vkCreateInstance, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateInstance, sizeof(uint32_t));
+ marshal_VkInstanceCreateInfo(stream, (VkInstanceCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_2 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_2);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_3;
+ stream->handleMapping()->mapHandles_VkInstance_u64(pInstance, &cgen_var_3, 1);
+ stream->write((uint64_t*)&cgen_var_3, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_4;
+ stream->read((uint64_t*)&cgen_var_4, 8);
+ stream->handleMapping()->mapHandles_u64_VkInstance(&cgen_var_4, (VkInstance*)pInstance, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateInstance_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateInstance_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateInstance_VkResult_return;
+}
+
+void VkEncoder::vkDestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_5;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_5, 1);
+ countingStream->write((uint64_t*)&cgen_var_5, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_6 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_6);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyInstance = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyInstance = OP_vkDestroyInstance;
+ stream->write(&opcode_vkDestroyInstance, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyInstance, sizeof(uint32_t));
+ uint64_t cgen_var_7;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_7, 1);
+ stream->write((uint64_t*)&cgen_var_7, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_8 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_8);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkInstance((VkInstance*)&instance);
+}
+
+VkResult VkEncoder::vkEnumeratePhysicalDevices(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ local_instance = instance;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_9;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_9, 1);
+ countingStream->write((uint64_t*)&cgen_var_9, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_10 = (uint64_t)(uintptr_t)pPhysicalDeviceCount;
+ countingStream->putBe64(cgen_var_10);
+ if (pPhysicalDeviceCount)
+ {
+ countingStream->write((uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_11 = (uint64_t)(uintptr_t)pPhysicalDevices;
+ countingStream->putBe64(cgen_var_11);
+ if (pPhysicalDevices)
+ {
+ if ((*(pPhysicalDeviceCount)))
+ {
+ uint64_t* cgen_var_12;
+ countingStream->alloc((void**)&cgen_var_12, (*(pPhysicalDeviceCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(pPhysicalDevices, cgen_var_12, (*(pPhysicalDeviceCount)));
+ countingStream->write((uint64_t*)cgen_var_12, (*(pPhysicalDeviceCount)) * 8);
+ }
+ }
+ }
+ uint32_t packetSize_vkEnumeratePhysicalDevices = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkEnumeratePhysicalDevices = OP_vkEnumeratePhysicalDevices;
+ stream->write(&opcode_vkEnumeratePhysicalDevices, sizeof(uint32_t));
+ stream->write(&packetSize_vkEnumeratePhysicalDevices, sizeof(uint32_t));
+ uint64_t cgen_var_13;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_13, 1);
+ stream->write((uint64_t*)&cgen_var_13, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_14 = (uint64_t)(uintptr_t)pPhysicalDeviceCount;
+ stream->putBe64(cgen_var_14);
+ if (pPhysicalDeviceCount)
+ {
+ stream->write((uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ // WARNING PTR CHECK
+ uint64_t cgen_var_15 = (uint64_t)(uintptr_t)pPhysicalDevices;
+ stream->putBe64(cgen_var_15);
+ if (pPhysicalDevices)
+ {
+ if ((*(pPhysicalDeviceCount)))
+ {
+ uint64_t* cgen_var_16;
+ stream->alloc((void**)&cgen_var_16, (*(pPhysicalDeviceCount)) * 8);
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(pPhysicalDevices, cgen_var_16, (*(pPhysicalDeviceCount)));
+ stream->write((uint64_t*)cgen_var_16, (*(pPhysicalDeviceCount)) * 8);
+ }
+ }
+ stream->setHandleMapping(resources->unwrapMapping());
+ // WARNING PTR CHECK
+ uint32_t* check_pPhysicalDeviceCount;
+ check_pPhysicalDeviceCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPhysicalDeviceCount)
+ {
+ if (!(check_pPhysicalDeviceCount))
+ {
+ fprintf(stderr, "fatal: pPhysicalDeviceCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
+ }
+ stream->setHandleMapping(resources->createMapping());
+ // WARNING PTR CHECK
+ VkPhysicalDevice* check_pPhysicalDevices;
+ check_pPhysicalDevices = (VkPhysicalDevice*)(uintptr_t)stream->getBe64();
+ if (pPhysicalDevices)
+ {
+ if (!(check_pPhysicalDevices))
+ {
+ fprintf(stderr, "fatal: pPhysicalDevices inconsistent between guest and host\n");
+ }
+ if ((*(pPhysicalDeviceCount)))
+ {
+ uint64_t* cgen_var_19;
+ stream->alloc((void**)&cgen_var_19, (*(pPhysicalDeviceCount)) * 8);
+ stream->read((uint64_t*)cgen_var_19, (*(pPhysicalDeviceCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_19, (VkPhysicalDevice*)pPhysicalDevices, (*(pPhysicalDeviceCount)));
+ }
+ }
+ stream->unsetHandleMapping();
+ VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
+ stream->read(&vkEnumeratePhysicalDevices_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkEnumeratePhysicalDevices_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_20;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_20, 1);
+ countingStream->write((uint64_t*)&cgen_var_20, 1 * 8);
+ marshal_VkPhysicalDeviceFeatures(countingStream, (VkPhysicalDeviceFeatures*)(pFeatures));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceFeatures = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceFeatures = OP_vkGetPhysicalDeviceFeatures;
+ stream->write(&opcode_vkGetPhysicalDeviceFeatures, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceFeatures, sizeof(uint32_t));
+ uint64_t cgen_var_21;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_21, 1);
+ stream->write((uint64_t*)&cgen_var_21, 1 * 8);
+ marshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures));
+ unmarshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures));
+}
+
+void VkEncoder::vkGetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkFormat local_format;
+ local_physicalDevice = physicalDevice;
+ local_format = format;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_22;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_22, 1);
+ countingStream->write((uint64_t*)&cgen_var_22, 1 * 8);
+ countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ marshal_VkFormatProperties(countingStream, (VkFormatProperties*)(pFormatProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceFormatProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceFormatProperties = OP_vkGetPhysicalDeviceFormatProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t));
+ uint64_t cgen_var_23;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_23, 1);
+ stream->write((uint64_t*)&cgen_var_23, 1 * 8);
+ stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ marshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties));
+ unmarshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties));
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkFormat local_format;
+ VkImageType local_type;
+ VkImageTiling local_tiling;
+ VkImageUsageFlags local_usage;
+ VkImageCreateFlags local_flags;
+ local_physicalDevice = physicalDevice;
+ local_format = format;
+ local_type = type;
+ local_tiling = tiling;
+ local_usage = usage;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_24;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_24, 1);
+ countingStream->write((uint64_t*)&cgen_var_24, 1 * 8);
+ countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
+ countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+ countingStream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+ countingStream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
+ marshal_VkImageFormatProperties(countingStream, (VkImageFormatProperties*)(pImageFormatProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties = OP_vkGetPhysicalDeviceImageFormatProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t));
+ uint64_t cgen_var_25;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_25, 1);
+ stream->write((uint64_t*)&cgen_var_25, 1 * 8);
+ stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ stream->write((VkImageType*)&local_type, sizeof(VkImageType));
+ stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+ stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+ stream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
+ marshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties));
+ unmarshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties));
+ VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceImageFormatProperties_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_26;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_26, 1);
+ countingStream->write((uint64_t*)&cgen_var_26, 1 * 8);
+ marshal_VkPhysicalDeviceProperties(countingStream, (VkPhysicalDeviceProperties*)(pProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceProperties = OP_vkGetPhysicalDeviceProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceProperties, sizeof(uint32_t));
+ uint64_t cgen_var_27;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_27, 1);
+ stream->write((uint64_t*)&cgen_var_27, 1 * 8);
+ marshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties));
+ unmarshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_28;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_28, 1);
+ countingStream->write((uint64_t*)&cgen_var_28, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_29 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ countingStream->putBe64(cgen_var_29);
+ if (pQueueFamilyPropertyCount)
+ {
+ countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_30 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ countingStream->putBe64(cgen_var_30);
+ if (pQueueFamilyProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ marshal_VkQueueFamilyProperties(countingStream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties = OP_vkGetPhysicalDeviceQueueFamilyProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t));
+ uint64_t cgen_var_31;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_31, 1);
+ stream->write((uint64_t*)&cgen_var_31, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_32 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ stream->putBe64(cgen_var_32);
+ if (pQueueFamilyPropertyCount)
+ {
+ stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_33 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ stream->putBe64(cgen_var_33);
+ if (pQueueFamilyProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ marshal_VkQueueFamilyProperties(stream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pQueueFamilyPropertyCount;
+ check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pQueueFamilyPropertyCount)
+ {
+ if (!(check_pQueueFamilyPropertyCount))
+ {
+ fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkQueueFamilyProperties* check_pQueueFamilyProperties;
+ check_pQueueFamilyProperties = (VkQueueFamilyProperties*)(uintptr_t)stream->getBe64();
+ if (pQueueFamilyProperties)
+ {
+ if (!(check_pQueueFamilyProperties))
+ {
+ fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ unmarshal_VkQueueFamilyProperties(stream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+ }
+ }
+}
+
+void VkEncoder::vkGetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_36;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_36, 1);
+ countingStream->write((uint64_t*)&cgen_var_36, 1 * 8);
+ marshal_VkPhysicalDeviceMemoryProperties(countingStream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceMemoryProperties = OP_vkGetPhysicalDeviceMemoryProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t));
+ uint64_t cgen_var_37;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_37, 1);
+ stream->write((uint64_t*)&cgen_var_37, 1 * 8);
+ marshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
+ unmarshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
+}
+
+PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ char* local_pName;
+ local_instance = instance;
+ local_pName = nullptr;
+ if (pName)
+ {
+ local_pName = pool->strDup(pName);
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_38;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_38, 1);
+ countingStream->write((uint64_t*)&cgen_var_38, 1 * 8);
+ countingStream->putString(local_pName);
+ }
+ uint32_t packetSize_vkGetInstanceProcAddr = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetInstanceProcAddr = OP_vkGetInstanceProcAddr;
+ stream->write(&opcode_vkGetInstanceProcAddr, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetInstanceProcAddr, sizeof(uint32_t));
+ uint64_t cgen_var_39;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_39, 1);
+ stream->write((uint64_t*)&cgen_var_39, 1 * 8);
+ stream->putString(local_pName);
+ PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ stream->read(&vkGetInstanceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
+}
+
+PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(
+ VkDevice device,
+ const char* pName)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ char* local_pName;
+ local_device = device;
+ local_pName = nullptr;
+ if (pName)
+ {
+ local_pName = pool->strDup(pName);
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_40;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_40, 1);
+ countingStream->write((uint64_t*)&cgen_var_40, 1 * 8);
+ countingStream->putString(local_pName);
+ }
+ uint32_t packetSize_vkGetDeviceProcAddr = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDeviceProcAddr = OP_vkGetDeviceProcAddr;
+ stream->write(&opcode_vkGetDeviceProcAddr, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDeviceProcAddr, sizeof(uint32_t));
+ uint64_t cgen_var_41;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_41, 1);
+ stream->write((uint64_t*)&cgen_var_41, 1 * 8);
+ stream->putString(local_pName);
+ PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ stream->read(&vkGetDeviceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
+}
+
+VkResult VkEncoder::vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkDeviceCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_physicalDevice = physicalDevice;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDeviceCreateInfo*)pool->alloc(sizeof(const VkDeviceCreateInfo));
+ deepcopy_VkDeviceCreateInfo(pool, pCreateInfo, (VkDeviceCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_42;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_42, 1);
+ countingStream->write((uint64_t*)&cgen_var_42, 1 * 8);
+ marshal_VkDeviceCreateInfo(countingStream, (VkDeviceCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_43 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_43);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_44;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(pDevice, &cgen_var_44, 1);
+ countingStream->write((uint64_t*)&cgen_var_44, 8);
+ }
+ uint32_t packetSize_vkCreateDevice = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDevice = OP_vkCreateDevice;
+ stream->write(&opcode_vkCreateDevice, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDevice, sizeof(uint32_t));
+ uint64_t cgen_var_45;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_45, 1);
+ stream->write((uint64_t*)&cgen_var_45, 1 * 8);
+ marshal_VkDeviceCreateInfo(stream, (VkDeviceCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_46 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_46);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_47;
+ stream->handleMapping()->mapHandles_VkDevice_u64(pDevice, &cgen_var_47, 1);
+ stream->write((uint64_t*)&cgen_var_47, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_48;
+ stream->read((uint64_t*)&cgen_var_48, 8);
+ stream->handleMapping()->mapHandles_u64_VkDevice(&cgen_var_48, (VkDevice*)pDevice, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateDevice_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDevice_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ goldfish_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice, pCreateInfo, pAllocator, pDevice);
+ return vkCreateDevice_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDevice(
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_49;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_49, 1);
+ countingStream->write((uint64_t*)&cgen_var_49, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_50 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_50);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyDevice = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyDevice = OP_vkDestroyDevice;
+ stream->write(&opcode_vkDestroyDevice, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyDevice, sizeof(uint32_t));
+ uint64_t cgen_var_51;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_51, 1);
+ stream->write((uint64_t*)&cgen_var_51, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_52 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_52);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkDevice((VkDevice*)&device);
+}
+
+VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ char* local_pLayerName;
+ local_pLayerName = nullptr;
+ if (pLayerName)
+ {
+ local_pLayerName = pool->strDup(pLayerName);
+ }
+ countingStream->rewind();
+ {
+ countingStream->putString(local_pLayerName);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_53 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_53);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_54 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_54);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkExtensionProperties(countingStream, (VkExtensionProperties*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkEnumerateInstanceExtensionProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkEnumerateInstanceExtensionProperties = OP_vkEnumerateInstanceExtensionProperties;
+ stream->write(&opcode_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
+ stream->putString(local_pLayerName);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_55 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_55);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_56 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_56);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkExtensionProperties* check_pProperties;
+ check_pProperties = (VkExtensionProperties*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
+ }
+ }
+ VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
+ stream->read(&vkEnumerateInstanceExtensionProperties_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkEnumerateInstanceExtensionProperties_VkResult_return;
+}
+
+VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties)
+{
+ VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
+ vkEnumerateDeviceExtensionProperties_VkResult_return = goldfish_vkEnumerateDeviceExtensionProperties(this, vkEnumerateDeviceExtensionProperties_VkResult_return, physicalDevice, pLayerName, pPropertyCount, pProperties);
+ return vkEnumerateDeviceExtensionProperties_VkResult_return;
+}
+
+VkResult VkEncoder::vkEnumerateInstanceLayerProperties(
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ countingStream->rewind();
+ {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_59 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_59);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_60 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_60);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkLayerProperties(countingStream, (VkLayerProperties*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkEnumerateInstanceLayerProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkEnumerateInstanceLayerProperties = OP_vkEnumerateInstanceLayerProperties;
+ stream->write(&opcode_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_61 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_61);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_62 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_62);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkLayerProperties* check_pProperties;
+ check_pProperties = (VkLayerProperties*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+ }
+ }
+ VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+ stream->read(&vkEnumerateInstanceLayerProperties_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+
+VkResult VkEncoder::vkEnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_65;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_65, 1);
+ countingStream->write((uint64_t*)&cgen_var_65, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_66 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_66);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_67 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_67);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkLayerProperties(countingStream, (VkLayerProperties*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkEnumerateDeviceLayerProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkEnumerateDeviceLayerProperties = OP_vkEnumerateDeviceLayerProperties;
+ stream->write(&opcode_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
+ uint64_t cgen_var_68;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_68, 1);
+ stream->write((uint64_t*)&cgen_var_68, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_69 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_69);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_70 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_70);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkLayerProperties* check_pProperties;
+ check_pProperties = (VkLayerProperties*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
+ }
+ }
+ VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
+ stream->read(&vkEnumerateDeviceLayerProperties_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkEnumerateDeviceLayerProperties_VkResult_return;
+}
+
+void VkEncoder::vkGetDeviceQueue(
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_queueFamilyIndex;
+ uint32_t local_queueIndex;
+ local_device = device;
+ local_queueFamilyIndex = queueFamilyIndex;
+ local_queueIndex = queueIndex;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_73;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_73, 1);
+ countingStream->write((uint64_t*)&cgen_var_73, 1 * 8);
+ countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_queueIndex, sizeof(uint32_t));
+ uint64_t cgen_var_74;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_74, 1);
+ countingStream->write((uint64_t*)&cgen_var_74, 8);
+ }
+ uint32_t packetSize_vkGetDeviceQueue = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDeviceQueue = OP_vkGetDeviceQueue;
+ stream->write(&opcode_vkGetDeviceQueue, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDeviceQueue, sizeof(uint32_t));
+ uint64_t cgen_var_75;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_75, 1);
+ stream->write((uint64_t*)&cgen_var_75, 1 * 8);
+ stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_queueIndex, sizeof(uint32_t));
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_76;
+ stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_76, 1);
+ stream->write((uint64_t*)&cgen_var_76, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_77;
+ stream->read((uint64_t*)&cgen_var_77, 8);
+ stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_77, (VkQueue*)pQueue, 1);
+ stream->unsetHandleMapping();
+}
+
+VkResult VkEncoder::vkQueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ uint32_t local_submitCount;
+ VkSubmitInfo* local_pSubmits;
+ VkFence local_fence;
+ local_queue = queue;
+ local_submitCount = submitCount;
+ local_pSubmits = nullptr;
+ if (pSubmits)
+ {
+ 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));
+ }
+ }
+ local_fence = fence;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_78;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_78, 1);
+ countingStream->write((uint64_t*)&cgen_var_78, 1 * 8);
+ countingStream->write((uint32_t*)&local_submitCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
+ {
+ marshal_VkSubmitInfo(countingStream, (VkSubmitInfo*)(local_pSubmits + i));
+ }
+ uint64_t cgen_var_79;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_79, 1);
+ countingStream->write((uint64_t*)&cgen_var_79, 1 * 8);
+ }
+ uint32_t packetSize_vkQueueSubmit = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueueSubmit = OP_vkQueueSubmit;
+ stream->write(&opcode_vkQueueSubmit, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueSubmit, sizeof(uint32_t));
+ uint64_t cgen_var_80;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_80, 1);
+ stream->write((uint64_t*)&cgen_var_80, 1 * 8);
+ stream->write((uint32_t*)&local_submitCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
+ {
+ marshal_VkSubmitInfo(stream, (VkSubmitInfo*)(local_pSubmits + i));
+ }
+ uint64_t cgen_var_81;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_81, 1);
+ stream->write((uint64_t*)&cgen_var_81, 1 * 8);
+ VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
+ stream->read(&vkQueueSubmit_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkQueueSubmit_VkResult_return;
+}
+
+VkResult VkEncoder::vkQueueWaitIdle(
+ VkQueue queue)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ local_queue = queue;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_82;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_82, 1);
+ countingStream->write((uint64_t*)&cgen_var_82, 1 * 8);
+ }
+ uint32_t packetSize_vkQueueWaitIdle = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueueWaitIdle = OP_vkQueueWaitIdle;
+ stream->write(&opcode_vkQueueWaitIdle, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueWaitIdle, sizeof(uint32_t));
+ uint64_t cgen_var_83;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_83, 1);
+ stream->write((uint64_t*)&cgen_var_83, 1 * 8);
+ VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
+ stream->read(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkQueueWaitIdle_VkResult_return;
+}
+
+VkResult VkEncoder::vkDeviceWaitIdle(
+ VkDevice device)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ local_device = device;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_84;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_84, 1);
+ countingStream->write((uint64_t*)&cgen_var_84, 1 * 8);
+ }
+ uint32_t packetSize_vkDeviceWaitIdle = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDeviceWaitIdle = OP_vkDeviceWaitIdle;
+ stream->write(&opcode_vkDeviceWaitIdle, sizeof(uint32_t));
+ stream->write(&packetSize_vkDeviceWaitIdle, sizeof(uint32_t));
+ uint64_t cgen_var_85;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_85, 1);
+ stream->write((uint64_t*)&cgen_var_85, 1 * 8);
+ VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
+ stream->read(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkDeviceWaitIdle_VkResult_return;
+}
+
+VkResult VkEncoder::vkAllocateMemory(
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkMemoryAllocateInfo* local_pAllocateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pAllocateInfo = nullptr;
+ if (pAllocateInfo)
+ {
+ local_pAllocateInfo = (VkMemoryAllocateInfo*)pool->alloc(sizeof(const VkMemoryAllocateInfo));
+ deepcopy_VkMemoryAllocateInfo(pool, pAllocateInfo, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_86;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_86, 1);
+ countingStream->write((uint64_t*)&cgen_var_86, 1 * 8);
+ marshal_VkMemoryAllocateInfo(countingStream, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_87 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_87);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_88;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_88, 1);
+ countingStream->write((uint64_t*)&cgen_var_88, 8);
+ }
+ uint32_t packetSize_vkAllocateMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkAllocateMemory = OP_vkAllocateMemory;
+ stream->write(&opcode_vkAllocateMemory, sizeof(uint32_t));
+ stream->write(&packetSize_vkAllocateMemory, sizeof(uint32_t));
+ uint64_t cgen_var_89;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_89, 1);
+ stream->write((uint64_t*)&cgen_var_89, 1 * 8);
+ marshal_VkMemoryAllocateInfo(stream, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_90 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_90);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_91;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_91, 1);
+ stream->write((uint64_t*)&cgen_var_91, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_92;
+ stream->read((uint64_t*)&cgen_var_92, 8);
+ stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_92, (VkDeviceMemory*)pMemory, 1);
+ stream->unsetHandleMapping();
+ VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
+ stream->read(&vkAllocateMemory_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ goldfish_vkAllocateMemory(this, vkAllocateMemory_VkResult_return, device, pAllocateInfo, pAllocator, pMemory);
+ return vkAllocateMemory_VkResult_return;
+}
+
+void VkEncoder::vkFreeMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDeviceMemory local_memory;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_memory = memory;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_93;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_93, 1);
+ countingStream->write((uint64_t*)&cgen_var_93, 1 * 8);
+ uint64_t cgen_var_94;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_94, 1);
+ countingStream->write((uint64_t*)&cgen_var_94, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_95 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_95);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkFreeMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkFreeMemory = OP_vkFreeMemory;
+ stream->write(&opcode_vkFreeMemory, sizeof(uint32_t));
+ stream->write(&packetSize_vkFreeMemory, sizeof(uint32_t));
+ uint64_t cgen_var_96;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_96, 1);
+ stream->write((uint64_t*)&cgen_var_96, 1 * 8);
+ uint64_t cgen_var_97;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_97, 1);
+ stream->write((uint64_t*)&cgen_var_97, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_98 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_98);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
+}
+
+VkResult VkEncoder::vkMapMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData)
+{
+ VkResult vkMapMemory_VkResult_return = (VkResult)0;
+ vkMapMemory_VkResult_return = goldfish_vkMapMemory(this, vkMapMemory_VkResult_return, device, memory, offset, size, flags, ppData);
+ return vkMapMemory_VkResult_return;
+}
+
+void VkEncoder::vkUnmapMemory(
+ VkDevice device,
+ VkDeviceMemory memory)
+{
+ goldfish_vkUnmapMemory(this, device, memory);
+}
+
+VkResult VkEncoder::vkFlushMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkFlushMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_memoryRangeCount;
+ VkMappedMemoryRange* local_pMemoryRanges;
+ local_device = device;
+ local_memoryRangeCount = memoryRangeCount;
+ local_pMemoryRanges = nullptr;
+ if (pMemoryRanges)
+ {
+ local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+ {
+ deepcopy_VkMappedMemoryRange(pool, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_99;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_99, 1);
+ countingStream->write((uint64_t*)&cgen_var_99, 1 * 8);
+ countingStream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+ {
+ marshal_VkMappedMemoryRange(countingStream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ }
+ }
+ for (uint32_t i = 0; i < memoryRangeCount; ++i)
+ {
+ auto range = pMemoryRanges[i];
+ auto memory = pMemoryRanges[i].memory;
+ auto size = pMemoryRanges[i].size;
+ auto offset = pMemoryRanges[i].offset;
+ auto goldfishMem = as_goldfish_VkDeviceMemory(memory);
+ uint64_t streamSize = 0;
+ if (!goldfishMem) { countingStream->write(&streamSize, sizeof(uint64_t)); continue; };
+ auto hostPtr = goldfishMem->ptr;
+ auto actualSize = size == VK_WHOLE_SIZE ? goldfishMem->size : size;
+ if (!hostPtr) { countingStream->write(&streamSize, sizeof(uint64_t)); continue; };
+ streamSize = actualSize;
+ countingStream->write(&streamSize, sizeof(uint64_t));
+ uint8_t* targetRange = hostPtr + offset;
+ countingStream->write(targetRange, actualSize);
+ }
+ uint32_t packetSize_vkFlushMappedMemoryRanges = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkFlushMappedMemoryRanges = OP_vkFlushMappedMemoryRanges;
+ stream->write(&opcode_vkFlushMappedMemoryRanges, sizeof(uint32_t));
+ stream->write(&packetSize_vkFlushMappedMemoryRanges, sizeof(uint32_t));
+ uint64_t cgen_var_100;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_100, 1);
+ stream->write((uint64_t*)&cgen_var_100, 1 * 8);
+ stream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+ {
+ marshal_VkMappedMemoryRange(stream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ }
+ for (uint32_t i = 0; i < memoryRangeCount; ++i)
+ {
+ auto range = pMemoryRanges[i];
+ auto memory = pMemoryRanges[i].memory;
+ auto size = pMemoryRanges[i].size;
+ auto offset = pMemoryRanges[i].offset;
+ auto goldfishMem = as_goldfish_VkDeviceMemory(memory);
+ uint64_t streamSize = 0;
+ if (!goldfishMem) { stream->write(&streamSize, sizeof(uint64_t)); continue; };
+ auto hostPtr = goldfishMem->ptr;
+ auto actualSize = size == VK_WHOLE_SIZE ? goldfishMem->size : size;
+ if (!hostPtr) { stream->write(&streamSize, sizeof(uint64_t)); continue; };
+ streamSize = actualSize;
+ stream->write(&streamSize, sizeof(uint64_t));
+ uint8_t* targetRange = hostPtr + offset;
+ stream->write(targetRange, actualSize);
+ }
+ VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
+ stream->read(&vkFlushMappedMemoryRanges_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkFlushMappedMemoryRanges_VkResult_return;
+}
+
+VkResult VkEncoder::vkInvalidateMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkInvalidateMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_memoryRangeCount;
+ VkMappedMemoryRange* local_pMemoryRanges;
+ local_device = device;
+ local_memoryRangeCount = memoryRangeCount;
+ local_pMemoryRanges = nullptr;
+ if (pMemoryRanges)
+ {
+ local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+ {
+ deepcopy_VkMappedMemoryRange(pool, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_101;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_101, 1);
+ countingStream->write((uint64_t*)&cgen_var_101, 1 * 8);
+ countingStream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+ {
+ marshal_VkMappedMemoryRange(countingStream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ }
+ }
+ uint32_t packetSize_vkInvalidateMappedMemoryRanges = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkInvalidateMappedMemoryRanges = OP_vkInvalidateMappedMemoryRanges;
+ stream->write(&opcode_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
+ stream->write(&packetSize_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
+ uint64_t cgen_var_102;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_102, 1);
+ stream->write((uint64_t*)&cgen_var_102, 1 * 8);
+ stream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
+ {
+ marshal_VkMappedMemoryRange(stream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ }
+ VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
+ stream->read(&vkInvalidateMappedMemoryRanges_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ for (uint32_t i = 0; i < memoryRangeCount; ++i)
+ {
+ auto range = pMemoryRanges[i];
+ auto memory = pMemoryRanges[i].memory;
+ auto size = pMemoryRanges[i].size;
+ auto offset = pMemoryRanges[i].offset;
+ auto goldfishMem = as_goldfish_VkDeviceMemory(memory);
+ uint64_t streamSize = 0;
+ if (!goldfishMem) { stream->read(&streamSize, sizeof(uint64_t)); continue; };
+ auto hostPtr = goldfishMem->ptr;
+ auto actualSize = size == VK_WHOLE_SIZE ? goldfishMem->size : size;
+ if (!hostPtr) { stream->read(&streamSize, sizeof(uint64_t)); continue; };
+ streamSize = actualSize;
+ stream->read(&streamSize, sizeof(uint64_t));
+ uint8_t* targetRange = hostPtr + offset;
+ stream->read(targetRange, actualSize);
+ }
+ return vkInvalidateMappedMemoryRanges_VkResult_return;
+}
+
+void VkEncoder::vkGetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDeviceMemory local_memory;
+ local_device = device;
+ local_memory = memory;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_103;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_103, 1);
+ countingStream->write((uint64_t*)&cgen_var_103, 1 * 8);
+ uint64_t cgen_var_104;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_104, 1);
+ countingStream->write((uint64_t*)&cgen_var_104, 1 * 8);
+ countingStream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
+ }
+ uint32_t packetSize_vkGetDeviceMemoryCommitment = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDeviceMemoryCommitment = OP_vkGetDeviceMemoryCommitment;
+ stream->write(&opcode_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
+ uint64_t cgen_var_105;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_105, 1);
+ stream->write((uint64_t*)&cgen_var_105, 1 * 8);
+ uint64_t cgen_var_106;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_106, 1);
+ stream->write((uint64_t*)&cgen_var_106, 1 * 8);
+ stream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
+ stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
+}
+
+VkResult VkEncoder::vkBindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBuffer local_buffer;
+ VkDeviceMemory local_memory;
+ VkDeviceSize local_memoryOffset;
+ local_device = device;
+ local_buffer = buffer;
+ local_memory = memory;
+ local_memoryOffset = memoryOffset;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_107;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_107, 1);
+ countingStream->write((uint64_t*)&cgen_var_107, 1 * 8);
+ uint64_t cgen_var_108;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_108, 1);
+ countingStream->write((uint64_t*)&cgen_var_108, 1 * 8);
+ uint64_t cgen_var_109;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_109, 1);
+ countingStream->write((uint64_t*)&cgen_var_109, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
+ }
+ uint32_t packetSize_vkBindBufferMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkBindBufferMemory = OP_vkBindBufferMemory;
+ stream->write(&opcode_vkBindBufferMemory, sizeof(uint32_t));
+ stream->write(&packetSize_vkBindBufferMemory, sizeof(uint32_t));
+ uint64_t cgen_var_110;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_110, 1);
+ stream->write((uint64_t*)&cgen_var_110, 1 * 8);
+ uint64_t cgen_var_111;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_111, 1);
+ stream->write((uint64_t*)&cgen_var_111, 1 * 8);
+ uint64_t cgen_var_112;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_112, 1);
+ stream->write((uint64_t*)&cgen_var_112, 1 * 8);
+ stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
+ VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
+ stream->read(&vkBindBufferMemory_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkBindBufferMemory_VkResult_return;
+}
+
+VkResult VkEncoder::vkBindImageMemory(
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImage local_image;
+ VkDeviceMemory local_memory;
+ VkDeviceSize local_memoryOffset;
+ local_device = device;
+ local_image = image;
+ local_memory = memory;
+ local_memoryOffset = memoryOffset;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_113;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_113, 1);
+ countingStream->write((uint64_t*)&cgen_var_113, 1 * 8);
+ uint64_t cgen_var_114;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_114, 1);
+ countingStream->write((uint64_t*)&cgen_var_114, 1 * 8);
+ uint64_t cgen_var_115;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_115, 1);
+ countingStream->write((uint64_t*)&cgen_var_115, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
+ }
+ uint32_t packetSize_vkBindImageMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkBindImageMemory = OP_vkBindImageMemory;
+ stream->write(&opcode_vkBindImageMemory, sizeof(uint32_t));
+ stream->write(&packetSize_vkBindImageMemory, sizeof(uint32_t));
+ uint64_t cgen_var_116;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_116, 1);
+ stream->write((uint64_t*)&cgen_var_116, 1 * 8);
+ uint64_t cgen_var_117;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_117, 1);
+ stream->write((uint64_t*)&cgen_var_117, 1 * 8);
+ uint64_t cgen_var_118;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_118, 1);
+ stream->write((uint64_t*)&cgen_var_118, 1 * 8);
+ stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
+ VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
+ stream->read(&vkBindImageMemory_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkBindImageMemory_VkResult_return;
+}
+
+void VkEncoder::vkGetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBuffer local_buffer;
+ local_device = device;
+ local_buffer = buffer;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_119;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_119, 1);
+ countingStream->write((uint64_t*)&cgen_var_119, 1 * 8);
+ uint64_t cgen_var_120;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_120, 1);
+ countingStream->write((uint64_t*)&cgen_var_120, 1 * 8);
+ marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkGetBufferMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetBufferMemoryRequirements = OP_vkGetBufferMemoryRequirements;
+ stream->write(&opcode_vkGetBufferMemoryRequirements, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetBufferMemoryRequirements, sizeof(uint32_t));
+ uint64_t cgen_var_121;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_121, 1);
+ stream->write((uint64_t*)&cgen_var_121, 1 * 8);
+ uint64_t cgen_var_122;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_122, 1);
+ stream->write((uint64_t*)&cgen_var_122, 1 * 8);
+ marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImage local_image;
+ local_device = device;
+ local_image = image;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_123;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_123, 1);
+ countingStream->write((uint64_t*)&cgen_var_123, 1 * 8);
+ uint64_t cgen_var_124;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_124, 1);
+ countingStream->write((uint64_t*)&cgen_var_124, 1 * 8);
+ marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkGetImageMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetImageMemoryRequirements = OP_vkGetImageMemoryRequirements;
+ stream->write(&opcode_vkGetImageMemoryRequirements, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetImageMemoryRequirements, sizeof(uint32_t));
+ uint64_t cgen_var_125;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_125, 1);
+ stream->write((uint64_t*)&cgen_var_125, 1 * 8);
+ uint64_t cgen_var_126;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_126, 1);
+ stream->write((uint64_t*)&cgen_var_126, 1 * 8);
+ marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImage local_image;
+ local_device = device;
+ local_image = image;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_127;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_127, 1);
+ countingStream->write((uint64_t*)&cgen_var_127, 1 * 8);
+ uint64_t cgen_var_128;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_128, 1);
+ countingStream->write((uint64_t*)&cgen_var_128, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_129 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ countingStream->putBe64(cgen_var_129);
+ if (pSparseMemoryRequirementCount)
+ {
+ countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_130 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ countingStream->putBe64(cgen_var_130);
+ if (pSparseMemoryRequirements)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ marshal_VkSparseImageMemoryRequirements(countingStream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetImageSparseMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetImageSparseMemoryRequirements = OP_vkGetImageSparseMemoryRequirements;
+ stream->write(&opcode_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
+ uint64_t cgen_var_131;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_131, 1);
+ stream->write((uint64_t*)&cgen_var_131, 1 * 8);
+ uint64_t cgen_var_132;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_132, 1);
+ stream->write((uint64_t*)&cgen_var_132, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_133 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ stream->putBe64(cgen_var_133);
+ if (pSparseMemoryRequirementCount)
+ {
+ stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_134 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ stream->putBe64(cgen_var_134);
+ if (pSparseMemoryRequirements)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ marshal_VkSparseImageMemoryRequirements(stream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pSparseMemoryRequirementCount;
+ check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirementCount)
+ {
+ if (!(check_pSparseMemoryRequirementCount))
+ {
+ fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkSparseImageMemoryRequirements* check_pSparseMemoryRequirements;
+ check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirements)
+ {
+ if (!(check_pSparseMemoryRequirements))
+ {
+ fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ unmarshal_VkSparseImageMemoryRequirements(stream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+ }
+ }
+}
+
+void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkFormat local_format;
+ VkImageType local_type;
+ VkSampleCountFlagBits local_samples;
+ VkImageUsageFlags local_usage;
+ VkImageTiling local_tiling;
+ local_physicalDevice = physicalDevice;
+ local_format = format;
+ local_type = type;
+ local_samples = samples;
+ local_usage = usage;
+ local_tiling = tiling;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_137;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_137, 1);
+ countingStream->write((uint64_t*)&cgen_var_137, 1 * 8);
+ countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
+ countingStream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
+ countingStream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+ countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_138 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_138);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_139 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_139);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkSparseImageFormatProperties(countingStream, (VkSparseImageFormatProperties*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties = OP_vkGetPhysicalDeviceSparseImageFormatProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
+ uint64_t cgen_var_140;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_140, 1);
+ stream->write((uint64_t*)&cgen_var_140, 1 * 8);
+ stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ stream->write((VkImageType*)&local_type, sizeof(VkImageType));
+ stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
+ stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+ stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_141 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_141);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_142 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_142);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkSparseImageFormatProperties(stream, (VkSparseImageFormatProperties*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkSparseImageFormatProperties* check_pProperties;
+ check_pProperties = (VkSparseImageFormatProperties*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkSparseImageFormatProperties(stream, (VkSparseImageFormatProperties*)(pProperties + i));
+ }
+ }
+}
+
+VkResult VkEncoder::vkQueueBindSparse(
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ uint32_t local_bindInfoCount;
+ VkBindSparseInfo* local_pBindInfo;
+ VkFence local_fence;
+ local_queue = queue;
+ local_bindInfoCount = bindInfoCount;
+ local_pBindInfo = nullptr;
+ if (pBindInfo)
+ {
+ local_pBindInfo = (VkBindSparseInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindSparseInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ deepcopy_VkBindSparseInfo(pool, pBindInfo + i, (VkBindSparseInfo*)(local_pBindInfo + i));
+ }
+ }
+ local_fence = fence;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_145;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_145, 1);
+ countingStream->write((uint64_t*)&cgen_var_145, 1 * 8);
+ countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindSparseInfo(countingStream, (VkBindSparseInfo*)(local_pBindInfo + i));
+ }
+ uint64_t cgen_var_146;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_146, 1);
+ countingStream->write((uint64_t*)&cgen_var_146, 1 * 8);
+ }
+ uint32_t packetSize_vkQueueBindSparse = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueueBindSparse = OP_vkQueueBindSparse;
+ stream->write(&opcode_vkQueueBindSparse, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueBindSparse, sizeof(uint32_t));
+ uint64_t cgen_var_147;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_147, 1);
+ stream->write((uint64_t*)&cgen_var_147, 1 * 8);
+ stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindSparseInfo(stream, (VkBindSparseInfo*)(local_pBindInfo + i));
+ }
+ uint64_t cgen_var_148;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_148, 1);
+ stream->write((uint64_t*)&cgen_var_148, 1 * 8);
+ VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
+ stream->read(&vkQueueBindSparse_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkQueueBindSparse_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkFenceCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkFenceCreateInfo*)pool->alloc(sizeof(const VkFenceCreateInfo));
+ deepcopy_VkFenceCreateInfo(pool, pCreateInfo, (VkFenceCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_149;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_149, 1);
+ countingStream->write((uint64_t*)&cgen_var_149, 1 * 8);
+ marshal_VkFenceCreateInfo(countingStream, (VkFenceCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_150 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_150);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_151;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_151, 1);
+ countingStream->write((uint64_t*)&cgen_var_151, 8);
+ }
+ uint32_t packetSize_vkCreateFence = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateFence = OP_vkCreateFence;
+ stream->write(&opcode_vkCreateFence, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateFence, sizeof(uint32_t));
+ uint64_t cgen_var_152;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_152, 1);
+ stream->write((uint64_t*)&cgen_var_152, 1 * 8);
+ marshal_VkFenceCreateInfo(stream, (VkFenceCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_153 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_153);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_154;
+ stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_154, 1);
+ stream->write((uint64_t*)&cgen_var_154, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_155;
+ stream->read((uint64_t*)&cgen_var_155, 8);
+ stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_155, (VkFence*)pFence, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateFence_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateFence_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateFence_VkResult_return;
+}
+
+void VkEncoder::vkDestroyFence(
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkFence local_fence;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_fence = fence;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_156;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_156, 1);
+ countingStream->write((uint64_t*)&cgen_var_156, 1 * 8);
+ uint64_t cgen_var_157;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_157, 1);
+ countingStream->write((uint64_t*)&cgen_var_157, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_158 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_158);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyFence = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyFence = OP_vkDestroyFence;
+ stream->write(&opcode_vkDestroyFence, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyFence, sizeof(uint32_t));
+ uint64_t cgen_var_159;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_159, 1);
+ stream->write((uint64_t*)&cgen_var_159, 1 * 8);
+ uint64_t cgen_var_160;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_160, 1);
+ stream->write((uint64_t*)&cgen_var_160, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_161 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_161);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkFence((VkFence*)&fence);
+}
+
+VkResult VkEncoder::vkResetFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_fenceCount;
+ VkFence* local_pFences;
+ local_device = device;
+ local_fenceCount = fenceCount;
+ local_pFences = nullptr;
+ if (pFences)
+ {
+ local_pFences = (VkFence*)pool->dupArray(pFences, ((fenceCount)) * sizeof(const VkFence));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_162;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_162, 1);
+ countingStream->write((uint64_t*)&cgen_var_162, 1 * 8);
+ countingStream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
+ if (((fenceCount)))
+ {
+ uint64_t* cgen_var_163;
+ countingStream->alloc((void**)&cgen_var_163, ((fenceCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_163, ((fenceCount)));
+ countingStream->write((uint64_t*)cgen_var_163, ((fenceCount)) * 8);
+ }
+ }
+ uint32_t packetSize_vkResetFences = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkResetFences = OP_vkResetFences;
+ stream->write(&opcode_vkResetFences, sizeof(uint32_t));
+ stream->write(&packetSize_vkResetFences, sizeof(uint32_t));
+ uint64_t cgen_var_164;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_164, 1);
+ stream->write((uint64_t*)&cgen_var_164, 1 * 8);
+ stream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
+ if (((fenceCount)))
+ {
+ uint64_t* cgen_var_165;
+ stream->alloc((void**)&cgen_var_165, ((fenceCount)) * 8);
+ stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_165, ((fenceCount)));
+ stream->write((uint64_t*)cgen_var_165, ((fenceCount)) * 8);
+ }
+ VkResult vkResetFences_VkResult_return = (VkResult)0;
+ stream->read(&vkResetFences_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkResetFences_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetFenceStatus(
+ VkDevice device,
+ VkFence fence)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkFence local_fence;
+ local_device = device;
+ local_fence = fence;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_166;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_166, 1);
+ countingStream->write((uint64_t*)&cgen_var_166, 1 * 8);
+ uint64_t cgen_var_167;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_167, 1);
+ countingStream->write((uint64_t*)&cgen_var_167, 1 * 8);
+ }
+ uint32_t packetSize_vkGetFenceStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetFenceStatus = OP_vkGetFenceStatus;
+ stream->write(&opcode_vkGetFenceStatus, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetFenceStatus, sizeof(uint32_t));
+ uint64_t cgen_var_168;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_168, 1);
+ stream->write((uint64_t*)&cgen_var_168, 1 * 8);
+ uint64_t cgen_var_169;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_169, 1);
+ stream->write((uint64_t*)&cgen_var_169, 1 * 8);
+ VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
+ stream->read(&vkGetFenceStatus_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetFenceStatus_VkResult_return;
+}
+
+VkResult VkEncoder::vkWaitForFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_fenceCount;
+ VkFence* local_pFences;
+ VkBool32 local_waitAll;
+ uint64_t local_timeout;
+ local_device = device;
+ local_fenceCount = fenceCount;
+ local_pFences = nullptr;
+ if (pFences)
+ {
+ local_pFences = (VkFence*)pool->dupArray(pFences, ((fenceCount)) * sizeof(const VkFence));
+ }
+ local_waitAll = waitAll;
+ local_timeout = timeout;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_170;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_170, 1);
+ countingStream->write((uint64_t*)&cgen_var_170, 1 * 8);
+ countingStream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
+ if (((fenceCount)))
+ {
+ uint64_t* cgen_var_171;
+ countingStream->alloc((void**)&cgen_var_171, ((fenceCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_171, ((fenceCount)));
+ countingStream->write((uint64_t*)cgen_var_171, ((fenceCount)) * 8);
+ }
+ countingStream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
+ countingStream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
+ }
+ uint32_t packetSize_vkWaitForFences = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkWaitForFences = OP_vkWaitForFences;
+ stream->write(&opcode_vkWaitForFences, sizeof(uint32_t));
+ stream->write(&packetSize_vkWaitForFences, sizeof(uint32_t));
+ uint64_t cgen_var_172;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_172, 1);
+ stream->write((uint64_t*)&cgen_var_172, 1 * 8);
+ stream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
+ if (((fenceCount)))
+ {
+ uint64_t* cgen_var_173;
+ stream->alloc((void**)&cgen_var_173, ((fenceCount)) * 8);
+ stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_173, ((fenceCount)));
+ stream->write((uint64_t*)cgen_var_173, ((fenceCount)) * 8);
+ }
+ stream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
+ stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
+ VkResult vkWaitForFences_VkResult_return = (VkResult)0;
+ stream->read(&vkWaitForFences_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkWaitForFences_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSemaphoreCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkSemaphoreCreateInfo*)pool->alloc(sizeof(const VkSemaphoreCreateInfo));
+ deepcopy_VkSemaphoreCreateInfo(pool, pCreateInfo, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_174;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_174, 1);
+ countingStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+ marshal_VkSemaphoreCreateInfo(countingStream, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_175 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_175);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_176;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_176, 1);
+ countingStream->write((uint64_t*)&cgen_var_176, 8);
+ }
+ uint32_t packetSize_vkCreateSemaphore = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateSemaphore = OP_vkCreateSemaphore;
+ stream->write(&opcode_vkCreateSemaphore, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateSemaphore, sizeof(uint32_t));
+ uint64_t cgen_var_177;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_177, 1);
+ stream->write((uint64_t*)&cgen_var_177, 1 * 8);
+ marshal_VkSemaphoreCreateInfo(stream, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_178 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_178);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_179;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_179, 1);
+ stream->write((uint64_t*)&cgen_var_179, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_180;
+ stream->read((uint64_t*)&cgen_var_180, 8);
+ stream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_180, (VkSemaphore*)pSemaphore, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateSemaphore_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateSemaphore_VkResult_return;
+}
+
+void VkEncoder::vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSemaphore local_semaphore;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_semaphore = semaphore;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_181;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_181, 1);
+ countingStream->write((uint64_t*)&cgen_var_181, 1 * 8);
+ uint64_t cgen_var_182;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_182, 1);
+ countingStream->write((uint64_t*)&cgen_var_182, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_183 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_183);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroySemaphore = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroySemaphore = OP_vkDestroySemaphore;
+ stream->write(&opcode_vkDestroySemaphore, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroySemaphore, sizeof(uint32_t));
+ uint64_t cgen_var_184;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_184, 1);
+ stream->write((uint64_t*)&cgen_var_184, 1 * 8);
+ uint64_t cgen_var_185;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_185, 1);
+ stream->write((uint64_t*)&cgen_var_185, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_186 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_186);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkSemaphore((VkSemaphore*)&semaphore);
+}
+
+VkResult VkEncoder::vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkEventCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkEventCreateInfo*)pool->alloc(sizeof(const VkEventCreateInfo));
+ deepcopy_VkEventCreateInfo(pool, pCreateInfo, (VkEventCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_187;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_187, 1);
+ countingStream->write((uint64_t*)&cgen_var_187, 1 * 8);
+ marshal_VkEventCreateInfo(countingStream, (VkEventCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_188 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_188);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_189;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_189, 1);
+ countingStream->write((uint64_t*)&cgen_var_189, 8);
+ }
+ uint32_t packetSize_vkCreateEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateEvent = OP_vkCreateEvent;
+ stream->write(&opcode_vkCreateEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateEvent, sizeof(uint32_t));
+ uint64_t cgen_var_190;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_190, 1);
+ stream->write((uint64_t*)&cgen_var_190, 1 * 8);
+ marshal_VkEventCreateInfo(stream, (VkEventCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_191 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_191);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_192;
+ stream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_192, 1);
+ stream->write((uint64_t*)&cgen_var_192, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_193;
+ stream->read((uint64_t*)&cgen_var_193, 8);
+ stream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_193, (VkEvent*)pEvent, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateEvent_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateEvent_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateEvent_VkResult_return;
+}
+
+void VkEncoder::vkDestroyEvent(
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkEvent local_event;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_event = event;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_194;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_194, 1);
+ countingStream->write((uint64_t*)&cgen_var_194, 1 * 8);
+ uint64_t cgen_var_195;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_195, 1);
+ countingStream->write((uint64_t*)&cgen_var_195, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_196 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_196);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyEvent = OP_vkDestroyEvent;
+ stream->write(&opcode_vkDestroyEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyEvent, sizeof(uint32_t));
+ uint64_t cgen_var_197;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_197, 1);
+ stream->write((uint64_t*)&cgen_var_197, 1 * 8);
+ uint64_t cgen_var_198;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_198, 1);
+ stream->write((uint64_t*)&cgen_var_198, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_199 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_199);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkEvent((VkEvent*)&event);
+}
+
+VkResult VkEncoder::vkGetEventStatus(
+ VkDevice device,
+ VkEvent event)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkEvent local_event;
+ local_device = device;
+ local_event = event;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_200;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_200, 1);
+ countingStream->write((uint64_t*)&cgen_var_200, 1 * 8);
+ uint64_t cgen_var_201;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_201, 1);
+ countingStream->write((uint64_t*)&cgen_var_201, 1 * 8);
+ }
+ uint32_t packetSize_vkGetEventStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetEventStatus = OP_vkGetEventStatus;
+ stream->write(&opcode_vkGetEventStatus, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetEventStatus, sizeof(uint32_t));
+ uint64_t cgen_var_202;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_202, 1);
+ stream->write((uint64_t*)&cgen_var_202, 1 * 8);
+ uint64_t cgen_var_203;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_203, 1);
+ stream->write((uint64_t*)&cgen_var_203, 1 * 8);
+ VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
+ stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetEventStatus_VkResult_return;
+}
+
+VkResult VkEncoder::vkSetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkEvent local_event;
+ local_device = device;
+ local_event = event;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_204;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_204, 1);
+ countingStream->write((uint64_t*)&cgen_var_204, 1 * 8);
+ uint64_t cgen_var_205;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_205, 1);
+ countingStream->write((uint64_t*)&cgen_var_205, 1 * 8);
+ }
+ uint32_t packetSize_vkSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkSetEvent = OP_vkSetEvent;
+ stream->write(&opcode_vkSetEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkSetEvent, sizeof(uint32_t));
+ uint64_t cgen_var_206;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_206, 1);
+ stream->write((uint64_t*)&cgen_var_206, 1 * 8);
+ uint64_t cgen_var_207;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_207, 1);
+ stream->write((uint64_t*)&cgen_var_207, 1 * 8);
+ VkResult vkSetEvent_VkResult_return = (VkResult)0;
+ stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkSetEvent_VkResult_return;
+}
+
+VkResult VkEncoder::vkResetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkEvent local_event;
+ local_device = device;
+ local_event = event;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_208;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_208, 1);
+ countingStream->write((uint64_t*)&cgen_var_208, 1 * 8);
+ uint64_t cgen_var_209;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_209, 1);
+ countingStream->write((uint64_t*)&cgen_var_209, 1 * 8);
+ }
+ uint32_t packetSize_vkResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkResetEvent = OP_vkResetEvent;
+ stream->write(&opcode_vkResetEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkResetEvent, sizeof(uint32_t));
+ uint64_t cgen_var_210;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_210, 1);
+ stream->write((uint64_t*)&cgen_var_210, 1 * 8);
+ uint64_t cgen_var_211;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_211, 1);
+ stream->write((uint64_t*)&cgen_var_211, 1 * 8);
+ VkResult vkResetEvent_VkResult_return = (VkResult)0;
+ stream->read(&vkResetEvent_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkResetEvent_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkQueryPoolCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkQueryPoolCreateInfo*)pool->alloc(sizeof(const VkQueryPoolCreateInfo));
+ deepcopy_VkQueryPoolCreateInfo(pool, pCreateInfo, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_212;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_212, 1);
+ countingStream->write((uint64_t*)&cgen_var_212, 1 * 8);
+ marshal_VkQueryPoolCreateInfo(countingStream, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_213 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_213);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_214;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_214, 1);
+ countingStream->write((uint64_t*)&cgen_var_214, 8);
+ }
+ uint32_t packetSize_vkCreateQueryPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateQueryPool = OP_vkCreateQueryPool;
+ stream->write(&opcode_vkCreateQueryPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateQueryPool, sizeof(uint32_t));
+ uint64_t cgen_var_215;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_215, 1);
+ stream->write((uint64_t*)&cgen_var_215, 1 * 8);
+ marshal_VkQueryPoolCreateInfo(stream, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_216 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_216);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_217;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_217, 1);
+ stream->write((uint64_t*)&cgen_var_217, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_218;
+ stream->read((uint64_t*)&cgen_var_218, 8);
+ stream->handleMapping()->mapHandles_u64_VkQueryPool(&cgen_var_218, (VkQueryPool*)pQueryPool, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateQueryPool_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateQueryPool_VkResult_return;
+}
+
+void VkEncoder::vkDestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkQueryPool local_queryPool;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_queryPool = queryPool;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_219;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_219, 1);
+ countingStream->write((uint64_t*)&cgen_var_219, 1 * 8);
+ uint64_t cgen_var_220;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_220, 1);
+ countingStream->write((uint64_t*)&cgen_var_220, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_221 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_221);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyQueryPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyQueryPool = OP_vkDestroyQueryPool;
+ stream->write(&opcode_vkDestroyQueryPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyQueryPool, sizeof(uint32_t));
+ uint64_t cgen_var_222;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_222, 1);
+ stream->write((uint64_t*)&cgen_var_222, 1 * 8);
+ uint64_t cgen_var_223;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_223, 1);
+ stream->write((uint64_t*)&cgen_var_223, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_224 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_224);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkQueryPool((VkQueryPool*)&queryPool);
+}
+
+VkResult VkEncoder::vkGetQueryPoolResults(
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkQueryPool local_queryPool;
+ uint32_t local_firstQuery;
+ uint32_t local_queryCount;
+ size_t local_dataSize;
+ VkDeviceSize local_stride;
+ VkQueryResultFlags local_flags;
+ local_device = device;
+ local_queryPool = queryPool;
+ local_firstQuery = firstQuery;
+ local_queryCount = queryCount;
+ local_dataSize = dataSize;
+ local_stride = stride;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_225;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_225, 1);
+ countingStream->write((uint64_t*)&cgen_var_225, 1 * 8);
+ uint64_t cgen_var_226;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_226, 1);
+ countingStream->write((uint64_t*)&cgen_var_226, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+ uint64_t cgen_var_227 = (uint64_t)local_dataSize;
+ countingStream->putBe64(cgen_var_227);
+ countingStream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
+ countingStream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
+ countingStream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
+ }
+ uint32_t packetSize_vkGetQueryPoolResults = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetQueryPoolResults = OP_vkGetQueryPoolResults;
+ stream->write(&opcode_vkGetQueryPoolResults, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetQueryPoolResults, sizeof(uint32_t));
+ uint64_t cgen_var_228;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_228, 1);
+ stream->write((uint64_t*)&cgen_var_228, 1 * 8);
+ uint64_t cgen_var_229;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_229, 1);
+ stream->write((uint64_t*)&cgen_var_229, 1 * 8);
+ stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+ uint64_t cgen_var_230 = (uint64_t)local_dataSize;
+ stream->putBe64(cgen_var_230);
+ stream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
+ stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
+ stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
+ stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
+ VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
+ stream->read(&vkGetQueryPoolResults_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetQueryPoolResults_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBufferCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkBufferCreateInfo*)pool->alloc(sizeof(const VkBufferCreateInfo));
+ deepcopy_VkBufferCreateInfo(pool, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_231;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_231, 1);
+ countingStream->write((uint64_t*)&cgen_var_231, 1 * 8);
+ marshal_VkBufferCreateInfo(countingStream, (VkBufferCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_232 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_232);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_233;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_233, 1);
+ countingStream->write((uint64_t*)&cgen_var_233, 8);
+ }
+ uint32_t packetSize_vkCreateBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateBuffer = OP_vkCreateBuffer;
+ stream->write(&opcode_vkCreateBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_234;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_234, 1);
+ stream->write((uint64_t*)&cgen_var_234, 1 * 8);
+ marshal_VkBufferCreateInfo(stream, (VkBufferCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_235 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_235);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_236;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_236, 1);
+ stream->write((uint64_t*)&cgen_var_236, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_237;
+ stream->read((uint64_t*)&cgen_var_237, 8);
+ stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_237, (VkBuffer*)pBuffer, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateBuffer_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateBuffer_VkResult_return;
+}
+
+void VkEncoder::vkDestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBuffer local_buffer;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_buffer = buffer;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_238;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_238, 1);
+ countingStream->write((uint64_t*)&cgen_var_238, 1 * 8);
+ uint64_t cgen_var_239;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_239, 1);
+ countingStream->write((uint64_t*)&cgen_var_239, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_240 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_240);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyBuffer = OP_vkDestroyBuffer;
+ stream->write(&opcode_vkDestroyBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_241;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_241, 1);
+ stream->write((uint64_t*)&cgen_var_241, 1 * 8);
+ uint64_t cgen_var_242;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_242, 1);
+ stream->write((uint64_t*)&cgen_var_242, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_243 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_243);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkBuffer((VkBuffer*)&buffer);
+}
+
+VkResult VkEncoder::vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBufferViewCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkBufferViewCreateInfo*)pool->alloc(sizeof(const VkBufferViewCreateInfo));
+ deepcopy_VkBufferViewCreateInfo(pool, pCreateInfo, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_244;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_244, 1);
+ countingStream->write((uint64_t*)&cgen_var_244, 1 * 8);
+ marshal_VkBufferViewCreateInfo(countingStream, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_245 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_245);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_246;
+ countingStream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_246, 1);
+ countingStream->write((uint64_t*)&cgen_var_246, 8);
+ }
+ uint32_t packetSize_vkCreateBufferView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateBufferView = OP_vkCreateBufferView;
+ stream->write(&opcode_vkCreateBufferView, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateBufferView, sizeof(uint32_t));
+ uint64_t cgen_var_247;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_247, 1);
+ stream->write((uint64_t*)&cgen_var_247, 1 * 8);
+ marshal_VkBufferViewCreateInfo(stream, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_248 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_248);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_249;
+ stream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_249, 1);
+ stream->write((uint64_t*)&cgen_var_249, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_250;
+ stream->read((uint64_t*)&cgen_var_250, 8);
+ stream->handleMapping()->mapHandles_u64_VkBufferView(&cgen_var_250, (VkBufferView*)pView, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateBufferView_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateBufferView_VkResult_return;
+}
+
+void VkEncoder::vkDestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBufferView local_bufferView;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_bufferView = bufferView;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_251;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_251, 1);
+ countingStream->write((uint64_t*)&cgen_var_251, 1 * 8);
+ uint64_t cgen_var_252;
+ countingStream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_252, 1);
+ countingStream->write((uint64_t*)&cgen_var_252, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_253 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_253);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyBufferView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyBufferView = OP_vkDestroyBufferView;
+ stream->write(&opcode_vkDestroyBufferView, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyBufferView, sizeof(uint32_t));
+ uint64_t cgen_var_254;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_254, 1);
+ stream->write((uint64_t*)&cgen_var_254, 1 * 8);
+ uint64_t cgen_var_255;
+ stream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_255, 1);
+ stream->write((uint64_t*)&cgen_var_255, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_256 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_256);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkBufferView((VkBufferView*)&bufferView);
+}
+
+VkResult VkEncoder::vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImageCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
+ deepcopy_VkImageCreateInfo(pool, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ goldfish_unwrap_VkNativeBufferANDROID(pCreateInfo, local_pCreateInfo);
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_257;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_257, 1);
+ countingStream->write((uint64_t*)&cgen_var_257, 1 * 8);
+ marshal_VkImageCreateInfo(countingStream, (VkImageCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_258 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_258);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_259;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_259, 1);
+ countingStream->write((uint64_t*)&cgen_var_259, 8);
+ }
+ uint32_t packetSize_vkCreateImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateImage = OP_vkCreateImage;
+ stream->write(&opcode_vkCreateImage, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateImage, sizeof(uint32_t));
+ uint64_t cgen_var_260;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_260, 1);
+ stream->write((uint64_t*)&cgen_var_260, 1 * 8);
+ marshal_VkImageCreateInfo(stream, (VkImageCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_261 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_261);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_262;
+ stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_262, 1);
+ stream->write((uint64_t*)&cgen_var_262, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_263;
+ stream->read((uint64_t*)&cgen_var_263, 8);
+ stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_263, (VkImage*)pImage, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateImage_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateImage_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateImage_VkResult_return;
+}
+
+void VkEncoder::vkDestroyImage(
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImage local_image;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_image = image;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_264;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_264, 1);
+ countingStream->write((uint64_t*)&cgen_var_264, 1 * 8);
+ uint64_t cgen_var_265;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_265, 1);
+ countingStream->write((uint64_t*)&cgen_var_265, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_266 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_266);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyImage = OP_vkDestroyImage;
+ stream->write(&opcode_vkDestroyImage, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyImage, sizeof(uint32_t));
+ uint64_t cgen_var_267;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_267, 1);
+ stream->write((uint64_t*)&cgen_var_267, 1 * 8);
+ uint64_t cgen_var_268;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_268, 1);
+ stream->write((uint64_t*)&cgen_var_268, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_269 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_269);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkImage((VkImage*)&image);
+}
+
+void VkEncoder::vkGetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImage local_image;
+ VkImageSubresource* local_pSubresource;
+ local_device = device;
+ local_image = image;
+ local_pSubresource = nullptr;
+ if (pSubresource)
+ {
+ local_pSubresource = (VkImageSubresource*)pool->alloc(sizeof(const VkImageSubresource));
+ deepcopy_VkImageSubresource(pool, pSubresource, (VkImageSubresource*)(local_pSubresource));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_270;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_270, 1);
+ countingStream->write((uint64_t*)&cgen_var_270, 1 * 8);
+ uint64_t cgen_var_271;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_271, 1);
+ countingStream->write((uint64_t*)&cgen_var_271, 1 * 8);
+ marshal_VkImageSubresource(countingStream, (VkImageSubresource*)(local_pSubresource));
+ marshal_VkSubresourceLayout(countingStream, (VkSubresourceLayout*)(pLayout));
+ }
+ uint32_t packetSize_vkGetImageSubresourceLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetImageSubresourceLayout = OP_vkGetImageSubresourceLayout;
+ stream->write(&opcode_vkGetImageSubresourceLayout, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetImageSubresourceLayout, sizeof(uint32_t));
+ uint64_t cgen_var_272;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_272, 1);
+ stream->write((uint64_t*)&cgen_var_272, 1 * 8);
+ uint64_t cgen_var_273;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_273, 1);
+ stream->write((uint64_t*)&cgen_var_273, 1 * 8);
+ marshal_VkImageSubresource(stream, (VkImageSubresource*)(local_pSubresource));
+ marshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
+ unmarshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
+}
+
+VkResult VkEncoder::vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImageViewCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkImageViewCreateInfo*)pool->alloc(sizeof(const VkImageViewCreateInfo));
+ deepcopy_VkImageViewCreateInfo(pool, pCreateInfo, (VkImageViewCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_274;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_274, 1);
+ countingStream->write((uint64_t*)&cgen_var_274, 1 * 8);
+ marshal_VkImageViewCreateInfo(countingStream, (VkImageViewCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_275 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_275);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_276;
+ countingStream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_276, 1);
+ countingStream->write((uint64_t*)&cgen_var_276, 8);
+ }
+ uint32_t packetSize_vkCreateImageView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateImageView = OP_vkCreateImageView;
+ stream->write(&opcode_vkCreateImageView, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateImageView, sizeof(uint32_t));
+ uint64_t cgen_var_277;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_277, 1);
+ stream->write((uint64_t*)&cgen_var_277, 1 * 8);
+ marshal_VkImageViewCreateInfo(stream, (VkImageViewCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_278 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_278);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_279;
+ stream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_279, 1);
+ stream->write((uint64_t*)&cgen_var_279, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_280;
+ stream->read((uint64_t*)&cgen_var_280, 8);
+ stream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_280, (VkImageView*)pView, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateImageView_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateImageView_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateImageView_VkResult_return;
+}
+
+void VkEncoder::vkDestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImageView local_imageView;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_imageView = imageView;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_281;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_281, 1);
+ countingStream->write((uint64_t*)&cgen_var_281, 1 * 8);
+ uint64_t cgen_var_282;
+ countingStream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_282, 1);
+ countingStream->write((uint64_t*)&cgen_var_282, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_283 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_283);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyImageView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyImageView = OP_vkDestroyImageView;
+ stream->write(&opcode_vkDestroyImageView, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyImageView, sizeof(uint32_t));
+ uint64_t cgen_var_284;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_284, 1);
+ stream->write((uint64_t*)&cgen_var_284, 1 * 8);
+ uint64_t cgen_var_285;
+ stream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_285, 1);
+ stream->write((uint64_t*)&cgen_var_285, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_286 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_286);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkImageView((VkImageView*)&imageView);
+}
+
+VkResult VkEncoder::vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkShaderModuleCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkShaderModuleCreateInfo*)pool->alloc(sizeof(const VkShaderModuleCreateInfo));
+ deepcopy_VkShaderModuleCreateInfo(pool, pCreateInfo, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_287;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_287, 1);
+ countingStream->write((uint64_t*)&cgen_var_287, 1 * 8);
+ marshal_VkShaderModuleCreateInfo(countingStream, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_288 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_288);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_289;
+ countingStream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_289, 1);
+ countingStream->write((uint64_t*)&cgen_var_289, 8);
+ }
+ uint32_t packetSize_vkCreateShaderModule = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateShaderModule = OP_vkCreateShaderModule;
+ stream->write(&opcode_vkCreateShaderModule, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateShaderModule, sizeof(uint32_t));
+ uint64_t cgen_var_290;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_290, 1);
+ stream->write((uint64_t*)&cgen_var_290, 1 * 8);
+ marshal_VkShaderModuleCreateInfo(stream, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_291 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_291);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_292;
+ stream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_292, 1);
+ stream->write((uint64_t*)&cgen_var_292, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_293;
+ stream->read((uint64_t*)&cgen_var_293, 8);
+ stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_293, (VkShaderModule*)pShaderModule, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateShaderModule_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateShaderModule_VkResult_return;
+}
+
+void VkEncoder::vkDestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkShaderModule local_shaderModule;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_shaderModule = shaderModule;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_294;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_294, 1);
+ countingStream->write((uint64_t*)&cgen_var_294, 1 * 8);
+ uint64_t cgen_var_295;
+ countingStream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_295, 1);
+ countingStream->write((uint64_t*)&cgen_var_295, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_296 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_296);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyShaderModule = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyShaderModule = OP_vkDestroyShaderModule;
+ stream->write(&opcode_vkDestroyShaderModule, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyShaderModule, sizeof(uint32_t));
+ uint64_t cgen_var_297;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_297, 1);
+ stream->write((uint64_t*)&cgen_var_297, 1 * 8);
+ uint64_t cgen_var_298;
+ stream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_298, 1);
+ stream->write((uint64_t*)&cgen_var_298, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_299 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_299);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkShaderModule((VkShaderModule*)&shaderModule);
+}
+
+VkResult VkEncoder::vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipelineCacheCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkPipelineCacheCreateInfo*)pool->alloc(sizeof(const VkPipelineCacheCreateInfo));
+ deepcopy_VkPipelineCacheCreateInfo(pool, pCreateInfo, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_300;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_300, 1);
+ countingStream->write((uint64_t*)&cgen_var_300, 1 * 8);
+ marshal_VkPipelineCacheCreateInfo(countingStream, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_301 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_301);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_302;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_302, 1);
+ countingStream->write((uint64_t*)&cgen_var_302, 8);
+ }
+ uint32_t packetSize_vkCreatePipelineCache = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreatePipelineCache = OP_vkCreatePipelineCache;
+ stream->write(&opcode_vkCreatePipelineCache, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreatePipelineCache, sizeof(uint32_t));
+ uint64_t cgen_var_303;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_303, 1);
+ stream->write((uint64_t*)&cgen_var_303, 1 * 8);
+ marshal_VkPipelineCacheCreateInfo(stream, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_304 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_304);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_305;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_305, 1);
+ stream->write((uint64_t*)&cgen_var_305, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_306;
+ stream->read((uint64_t*)&cgen_var_306, 8);
+ stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_306, (VkPipelineCache*)pPipelineCache, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
+ stream->read(&vkCreatePipelineCache_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreatePipelineCache_VkResult_return;
+}
+
+void VkEncoder::vkDestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipelineCache local_pipelineCache;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pipelineCache = pipelineCache;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_307;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_307, 1);
+ countingStream->write((uint64_t*)&cgen_var_307, 1 * 8);
+ uint64_t cgen_var_308;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_308, 1);
+ countingStream->write((uint64_t*)&cgen_var_308, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_309 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_309);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyPipelineCache = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyPipelineCache = OP_vkDestroyPipelineCache;
+ stream->write(&opcode_vkDestroyPipelineCache, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyPipelineCache, sizeof(uint32_t));
+ uint64_t cgen_var_310;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_310, 1);
+ stream->write((uint64_t*)&cgen_var_310, 1 * 8);
+ uint64_t cgen_var_311;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_311, 1);
+ stream->write((uint64_t*)&cgen_var_311, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_312 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_312);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkPipelineCache((VkPipelineCache*)&pipelineCache);
+}
+
+VkResult VkEncoder::vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipelineCache local_pipelineCache;
+ local_device = device;
+ local_pipelineCache = pipelineCache;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_313;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_313, 1);
+ countingStream->write((uint64_t*)&cgen_var_313, 1 * 8);
+ uint64_t cgen_var_314;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_314, 1);
+ countingStream->write((uint64_t*)&cgen_var_314, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_315 = (uint64_t)(uintptr_t)pDataSize;
+ countingStream->putBe64(cgen_var_315);
+ if (pDataSize)
+ {
+ uint64_t cgen_var_316 = (uint64_t)(*pDataSize);
+ countingStream->putBe64(cgen_var_316);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_317 = (uint64_t)(uintptr_t)pData;
+ countingStream->putBe64(cgen_var_317);
+ if (pData)
+ {
+ countingStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+ }
+ }
+ uint32_t packetSize_vkGetPipelineCacheData = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPipelineCacheData = OP_vkGetPipelineCacheData;
+ stream->write(&opcode_vkGetPipelineCacheData, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPipelineCacheData, sizeof(uint32_t));
+ uint64_t cgen_var_318;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_318, 1);
+ stream->write((uint64_t*)&cgen_var_318, 1 * 8);
+ uint64_t cgen_var_319;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_319, 1);
+ stream->write((uint64_t*)&cgen_var_319, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_320 = (uint64_t)(uintptr_t)pDataSize;
+ stream->putBe64(cgen_var_320);
+ if (pDataSize)
+ {
+ uint64_t cgen_var_321 = (uint64_t)(*pDataSize);
+ stream->putBe64(cgen_var_321);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_322 = (uint64_t)(uintptr_t)pData;
+ stream->putBe64(cgen_var_322);
+ if (pData)
+ {
+ stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+ }
+ // WARNING PTR CHECK
+ size_t* check_pDataSize;
+ check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
+ if (pDataSize)
+ {
+ if (!(check_pDataSize))
+ {
+ fprintf(stderr, "fatal: pDataSize inconsistent between guest and host\n");
+ }
+ (*pDataSize) = (size_t)stream->getBe64();
+ }
+ // WARNING PTR CHECK
+ void* check_pData;
+ check_pData = (void*)(uintptr_t)stream->getBe64();
+ if (pData)
+ {
+ if (!(check_pData))
+ {
+ fprintf(stderr, "fatal: pData inconsistent between guest and host\n");
+ }
+ stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+ }
+ VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPipelineCacheData_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPipelineCacheData_VkResult_return;
+}
+
+VkResult VkEncoder::vkMergePipelineCaches(
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipelineCache local_dstCache;
+ uint32_t local_srcCacheCount;
+ VkPipelineCache* local_pSrcCaches;
+ local_device = device;
+ local_dstCache = dstCache;
+ local_srcCacheCount = srcCacheCount;
+ local_pSrcCaches = nullptr;
+ if (pSrcCaches)
+ {
+ local_pSrcCaches = (VkPipelineCache*)pool->dupArray(pSrcCaches, ((srcCacheCount)) * sizeof(const VkPipelineCache));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_326;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_326, 1);
+ countingStream->write((uint64_t*)&cgen_var_326, 1 * 8);
+ uint64_t cgen_var_327;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_327, 1);
+ countingStream->write((uint64_t*)&cgen_var_327, 1 * 8);
+ countingStream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
+ if (((srcCacheCount)))
+ {
+ uint64_t* cgen_var_328;
+ countingStream->alloc((void**)&cgen_var_328, ((srcCacheCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_328, ((srcCacheCount)));
+ countingStream->write((uint64_t*)cgen_var_328, ((srcCacheCount)) * 8);
+ }
+ }
+ uint32_t packetSize_vkMergePipelineCaches = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkMergePipelineCaches = OP_vkMergePipelineCaches;
+ stream->write(&opcode_vkMergePipelineCaches, sizeof(uint32_t));
+ stream->write(&packetSize_vkMergePipelineCaches, sizeof(uint32_t));
+ uint64_t cgen_var_329;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_329, 1);
+ stream->write((uint64_t*)&cgen_var_329, 1 * 8);
+ uint64_t cgen_var_330;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_330, 1);
+ stream->write((uint64_t*)&cgen_var_330, 1 * 8);
+ stream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
+ if (((srcCacheCount)))
+ {
+ uint64_t* cgen_var_331;
+ stream->alloc((void**)&cgen_var_331, ((srcCacheCount)) * 8);
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_331, ((srcCacheCount)));
+ stream->write((uint64_t*)cgen_var_331, ((srcCacheCount)) * 8);
+ }
+ VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
+ stream->read(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkMergePipelineCaches_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipelineCache local_pipelineCache;
+ uint32_t local_createInfoCount;
+ VkGraphicsPipelineCreateInfo* local_pCreateInfos;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pipelineCache = pipelineCache;
+ local_createInfoCount = createInfoCount;
+ local_pCreateInfos = nullptr;
+ if (pCreateInfos)
+ {
+ local_pCreateInfos = (VkGraphicsPipelineCreateInfo*)pool->alloc(((createInfoCount)) * sizeof(const VkGraphicsPipelineCreateInfo));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+ {
+ deepcopy_VkGraphicsPipelineCreateInfo(pool, 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));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_332;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_332, 1);
+ countingStream->write((uint64_t*)&cgen_var_332, 1 * 8);
+ uint64_t cgen_var_333;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_333, 1);
+ countingStream->write((uint64_t*)&cgen_var_333, 1 * 8);
+ countingStream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+ {
+ marshal_VkGraphicsPipelineCreateInfo(countingStream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_334 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_334);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ if (((createInfoCount)))
+ {
+ uint64_t* cgen_var_335;
+ countingStream->alloc((void**)&cgen_var_335, ((createInfoCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_335, ((createInfoCount)));
+ countingStream->write((uint64_t*)cgen_var_335, ((createInfoCount)) * 8);
+ }
+ }
+ uint32_t packetSize_vkCreateGraphicsPipelines = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateGraphicsPipelines = OP_vkCreateGraphicsPipelines;
+ stream->write(&opcode_vkCreateGraphicsPipelines, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateGraphicsPipelines, sizeof(uint32_t));
+ uint64_t cgen_var_336;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_336, 1);
+ stream->write((uint64_t*)&cgen_var_336, 1 * 8);
+ uint64_t cgen_var_337;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_337, 1);
+ stream->write((uint64_t*)&cgen_var_337, 1 * 8);
+ stream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+ {
+ marshal_VkGraphicsPipelineCreateInfo(stream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_338 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_338);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ if (((createInfoCount)))
+ {
+ uint64_t* cgen_var_339;
+ stream->alloc((void**)&cgen_var_339, ((createInfoCount)) * 8);
+ stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_339, ((createInfoCount)));
+ stream->write((uint64_t*)cgen_var_339, ((createInfoCount)) * 8);
+ }
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ if (((createInfoCount)))
+ {
+ uint64_t* cgen_var_340;
+ stream->alloc((void**)&cgen_var_340, ((createInfoCount)) * 8);
+ stream->read((uint64_t*)cgen_var_340, ((createInfoCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_340, (VkPipeline*)pPipelines, ((createInfoCount)));
+ }
+ stream->unsetHandleMapping();
+ VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateGraphicsPipelines_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateGraphicsPipelines_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipelineCache local_pipelineCache;
+ uint32_t local_createInfoCount;
+ VkComputePipelineCreateInfo* local_pCreateInfos;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pipelineCache = pipelineCache;
+ local_createInfoCount = createInfoCount;
+ local_pCreateInfos = nullptr;
+ if (pCreateInfos)
+ {
+ local_pCreateInfos = (VkComputePipelineCreateInfo*)pool->alloc(((createInfoCount)) * sizeof(const VkComputePipelineCreateInfo));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+ {
+ deepcopy_VkComputePipelineCreateInfo(pool, 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));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_341;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_341, 1);
+ countingStream->write((uint64_t*)&cgen_var_341, 1 * 8);
+ uint64_t cgen_var_342;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_342, 1);
+ countingStream->write((uint64_t*)&cgen_var_342, 1 * 8);
+ countingStream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+ {
+ marshal_VkComputePipelineCreateInfo(countingStream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_343 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_343);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ if (((createInfoCount)))
+ {
+ uint64_t* cgen_var_344;
+ countingStream->alloc((void**)&cgen_var_344, ((createInfoCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_344, ((createInfoCount)));
+ countingStream->write((uint64_t*)cgen_var_344, ((createInfoCount)) * 8);
+ }
+ }
+ uint32_t packetSize_vkCreateComputePipelines = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateComputePipelines = OP_vkCreateComputePipelines;
+ stream->write(&opcode_vkCreateComputePipelines, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateComputePipelines, sizeof(uint32_t));
+ uint64_t cgen_var_345;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_345, 1);
+ stream->write((uint64_t*)&cgen_var_345, 1 * 8);
+ uint64_t cgen_var_346;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_346, 1);
+ stream->write((uint64_t*)&cgen_var_346, 1 * 8);
+ stream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
+ {
+ marshal_VkComputePipelineCreateInfo(stream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_347 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_347);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ if (((createInfoCount)))
+ {
+ uint64_t* cgen_var_348;
+ stream->alloc((void**)&cgen_var_348, ((createInfoCount)) * 8);
+ stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_348, ((createInfoCount)));
+ stream->write((uint64_t*)cgen_var_348, ((createInfoCount)) * 8);
+ }
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ if (((createInfoCount)))
+ {
+ uint64_t* cgen_var_349;
+ stream->alloc((void**)&cgen_var_349, ((createInfoCount)) * 8);
+ stream->read((uint64_t*)cgen_var_349, ((createInfoCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_349, (VkPipeline*)pPipelines, ((createInfoCount)));
+ }
+ stream->unsetHandleMapping();
+ VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateComputePipelines_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateComputePipelines_VkResult_return;
+}
+
+void VkEncoder::vkDestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipeline local_pipeline;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pipeline = pipeline;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_350;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_350, 1);
+ countingStream->write((uint64_t*)&cgen_var_350, 1 * 8);
+ uint64_t cgen_var_351;
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_351, 1);
+ countingStream->write((uint64_t*)&cgen_var_351, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_352 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_352);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyPipeline = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyPipeline = OP_vkDestroyPipeline;
+ stream->write(&opcode_vkDestroyPipeline, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyPipeline, sizeof(uint32_t));
+ uint64_t cgen_var_353;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_353, 1);
+ stream->write((uint64_t*)&cgen_var_353, 1 * 8);
+ uint64_t cgen_var_354;
+ stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_354, 1);
+ stream->write((uint64_t*)&cgen_var_354, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_355 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_355);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkPipeline((VkPipeline*)&pipeline);
+}
+
+VkResult VkEncoder::vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipelineLayoutCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkPipelineLayoutCreateInfo*)pool->alloc(sizeof(const VkPipelineLayoutCreateInfo));
+ deepcopy_VkPipelineLayoutCreateInfo(pool, pCreateInfo, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_356;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_356, 1);
+ countingStream->write((uint64_t*)&cgen_var_356, 1 * 8);
+ marshal_VkPipelineLayoutCreateInfo(countingStream, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_357 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_357);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_358;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_358, 1);
+ countingStream->write((uint64_t*)&cgen_var_358, 8);
+ }
+ uint32_t packetSize_vkCreatePipelineLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreatePipelineLayout = OP_vkCreatePipelineLayout;
+ stream->write(&opcode_vkCreatePipelineLayout, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreatePipelineLayout, sizeof(uint32_t));
+ uint64_t cgen_var_359;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_359, 1);
+ stream->write((uint64_t*)&cgen_var_359, 1 * 8);
+ marshal_VkPipelineLayoutCreateInfo(stream, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_360 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_360);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_361;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_361, 1);
+ stream->write((uint64_t*)&cgen_var_361, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_362;
+ stream->read((uint64_t*)&cgen_var_362, 8);
+ stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_362, (VkPipelineLayout*)pPipelineLayout, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
+ stream->read(&vkCreatePipelineLayout_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreatePipelineLayout_VkResult_return;
+}
+
+void VkEncoder::vkDestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipelineLayout local_pipelineLayout;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pipelineLayout = pipelineLayout;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_363;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_363, 1);
+ countingStream->write((uint64_t*)&cgen_var_363, 1 * 8);
+ uint64_t cgen_var_364;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_364, 1);
+ countingStream->write((uint64_t*)&cgen_var_364, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_365 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_365);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyPipelineLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyPipelineLayout = OP_vkDestroyPipelineLayout;
+ stream->write(&opcode_vkDestroyPipelineLayout, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyPipelineLayout, sizeof(uint32_t));
+ uint64_t cgen_var_366;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_366, 1);
+ stream->write((uint64_t*)&cgen_var_366, 1 * 8);
+ uint64_t cgen_var_367;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_367, 1);
+ stream->write((uint64_t*)&cgen_var_367, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_368 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_368);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkPipelineLayout((VkPipelineLayout*)&pipelineLayout);
+}
+
+VkResult VkEncoder::vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSamplerCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkSamplerCreateInfo*)pool->alloc(sizeof(const VkSamplerCreateInfo));
+ deepcopy_VkSamplerCreateInfo(pool, pCreateInfo, (VkSamplerCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_369;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_369, 1);
+ countingStream->write((uint64_t*)&cgen_var_369, 1 * 8);
+ marshal_VkSamplerCreateInfo(countingStream, (VkSamplerCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_370 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_370);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_371;
+ countingStream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_371, 1);
+ countingStream->write((uint64_t*)&cgen_var_371, 8);
+ }
+ uint32_t packetSize_vkCreateSampler = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateSampler = OP_vkCreateSampler;
+ stream->write(&opcode_vkCreateSampler, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateSampler, sizeof(uint32_t));
+ uint64_t cgen_var_372;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_372, 1);
+ stream->write((uint64_t*)&cgen_var_372, 1 * 8);
+ marshal_VkSamplerCreateInfo(stream, (VkSamplerCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_373 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_373);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_374;
+ stream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_374, 1);
+ stream->write((uint64_t*)&cgen_var_374, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_375;
+ stream->read((uint64_t*)&cgen_var_375, 8);
+ stream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_375, (VkSampler*)pSampler, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateSampler_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateSampler_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateSampler_VkResult_return;
+}
+
+void VkEncoder::vkDestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSampler local_sampler;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_sampler = sampler;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_376;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_376, 1);
+ countingStream->write((uint64_t*)&cgen_var_376, 1 * 8);
+ uint64_t cgen_var_377;
+ countingStream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_377, 1);
+ countingStream->write((uint64_t*)&cgen_var_377, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_378 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_378);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroySampler = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroySampler = OP_vkDestroySampler;
+ stream->write(&opcode_vkDestroySampler, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroySampler, sizeof(uint32_t));
+ uint64_t cgen_var_379;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_379, 1);
+ stream->write((uint64_t*)&cgen_var_379, 1 * 8);
+ uint64_t cgen_var_380;
+ stream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_380, 1);
+ stream->write((uint64_t*)&cgen_var_380, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_381 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_381);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkSampler((VkSampler*)&sampler);
+}
+
+VkResult VkEncoder::vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorSetLayoutCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_382;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_382, 1);
+ countingStream->write((uint64_t*)&cgen_var_382, 1 * 8);
+ marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_383 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_383);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_384;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_384, 1);
+ countingStream->write((uint64_t*)&cgen_var_384, 8);
+ }
+ uint32_t packetSize_vkCreateDescriptorSetLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDescriptorSetLayout = OP_vkCreateDescriptorSetLayout;
+ stream->write(&opcode_vkCreateDescriptorSetLayout, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDescriptorSetLayout, sizeof(uint32_t));
+ uint64_t cgen_var_385;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_385, 1);
+ stream->write((uint64_t*)&cgen_var_385, 1 * 8);
+ marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_386 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_386);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_387;
+ stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_387, 1);
+ stream->write((uint64_t*)&cgen_var_387, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_388;
+ stream->read((uint64_t*)&cgen_var_388, 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_388, (VkDescriptorSetLayout*)pSetLayout, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDescriptorSetLayout_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateDescriptorSetLayout_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorSetLayout local_descriptorSetLayout;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_descriptorSetLayout = descriptorSetLayout;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_389;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_389, 1);
+ countingStream->write((uint64_t*)&cgen_var_389, 1 * 8);
+ uint64_t cgen_var_390;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_390, 1);
+ countingStream->write((uint64_t*)&cgen_var_390, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_391 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_391);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyDescriptorSetLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyDescriptorSetLayout = OP_vkDestroyDescriptorSetLayout;
+ stream->write(&opcode_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
+ uint64_t cgen_var_392;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_392, 1);
+ stream->write((uint64_t*)&cgen_var_392, 1 * 8);
+ uint64_t cgen_var_393;
+ stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_393, 1);
+ stream->write((uint64_t*)&cgen_var_393, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_394 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_394);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&descriptorSetLayout);
+}
+
+VkResult VkEncoder::vkCreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorPoolCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDescriptorPoolCreateInfo*)pool->alloc(sizeof(const VkDescriptorPoolCreateInfo));
+ deepcopy_VkDescriptorPoolCreateInfo(pool, pCreateInfo, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_395;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_395, 1);
+ countingStream->write((uint64_t*)&cgen_var_395, 1 * 8);
+ marshal_VkDescriptorPoolCreateInfo(countingStream, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_396 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_396);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_397;
+ countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_397, 1);
+ countingStream->write((uint64_t*)&cgen_var_397, 8);
+ }
+ uint32_t packetSize_vkCreateDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDescriptorPool = OP_vkCreateDescriptorPool;
+ stream->write(&opcode_vkCreateDescriptorPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDescriptorPool, sizeof(uint32_t));
+ uint64_t cgen_var_398;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_398, 1);
+ stream->write((uint64_t*)&cgen_var_398, 1 * 8);
+ marshal_VkDescriptorPoolCreateInfo(stream, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_399 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_399);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_400;
+ stream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_400, 1);
+ stream->write((uint64_t*)&cgen_var_400, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_401;
+ stream->read((uint64_t*)&cgen_var_401, 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_401, (VkDescriptorPool*)pDescriptorPool, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDescriptorPool_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateDescriptorPool_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorPool local_descriptorPool;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_descriptorPool = descriptorPool;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_402;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_402, 1);
+ countingStream->write((uint64_t*)&cgen_var_402, 1 * 8);
+ uint64_t cgen_var_403;
+ countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_403, 1);
+ countingStream->write((uint64_t*)&cgen_var_403, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_404 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_404);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyDescriptorPool = OP_vkDestroyDescriptorPool;
+ stream->write(&opcode_vkDestroyDescriptorPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyDescriptorPool, sizeof(uint32_t));
+ uint64_t cgen_var_405;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_405, 1);
+ stream->write((uint64_t*)&cgen_var_405, 1 * 8);
+ uint64_t cgen_var_406;
+ stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_406, 1);
+ stream->write((uint64_t*)&cgen_var_406, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_407 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_407);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkDescriptorPool((VkDescriptorPool*)&descriptorPool);
+}
+
+VkResult VkEncoder::vkResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorPool local_descriptorPool;
+ VkDescriptorPoolResetFlags local_flags;
+ local_device = device;
+ local_descriptorPool = descriptorPool;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_408;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_408, 1);
+ countingStream->write((uint64_t*)&cgen_var_408, 1 * 8);
+ uint64_t cgen_var_409;
+ countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_409, 1);
+ countingStream->write((uint64_t*)&cgen_var_409, 1 * 8);
+ countingStream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
+ }
+ uint32_t packetSize_vkResetDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkResetDescriptorPool = OP_vkResetDescriptorPool;
+ stream->write(&opcode_vkResetDescriptorPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkResetDescriptorPool, sizeof(uint32_t));
+ uint64_t cgen_var_410;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_410, 1);
+ stream->write((uint64_t*)&cgen_var_410, 1 * 8);
+ uint64_t cgen_var_411;
+ stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_411, 1);
+ stream->write((uint64_t*)&cgen_var_411, 1 * 8);
+ stream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
+ VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
+ stream->read(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkResetDescriptorPool_VkResult_return;
+}
+
+VkResult VkEncoder::vkAllocateDescriptorSets(
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorSetAllocateInfo* local_pAllocateInfo;
+ local_device = device;
+ local_pAllocateInfo = nullptr;
+ if (pAllocateInfo)
+ {
+ local_pAllocateInfo = (VkDescriptorSetAllocateInfo*)pool->alloc(sizeof(const VkDescriptorSetAllocateInfo));
+ deepcopy_VkDescriptorSetAllocateInfo(pool, pAllocateInfo, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_412;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_412, 1);
+ countingStream->write((uint64_t*)&cgen_var_412, 1 * 8);
+ marshal_VkDescriptorSetAllocateInfo(countingStream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+ if (pAllocateInfo->descriptorSetCount)
+ {
+ uint64_t* cgen_var_413;
+ countingStream->alloc((void**)&cgen_var_413, pAllocateInfo->descriptorSetCount * 8);
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_413, pAllocateInfo->descriptorSetCount);
+ countingStream->write((uint64_t*)cgen_var_413, pAllocateInfo->descriptorSetCount * 8);
+ }
+ }
+ uint32_t packetSize_vkAllocateDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkAllocateDescriptorSets = OP_vkAllocateDescriptorSets;
+ stream->write(&opcode_vkAllocateDescriptorSets, sizeof(uint32_t));
+ stream->write(&packetSize_vkAllocateDescriptorSets, sizeof(uint32_t));
+ uint64_t cgen_var_414;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_414, 1);
+ stream->write((uint64_t*)&cgen_var_414, 1 * 8);
+ marshal_VkDescriptorSetAllocateInfo(stream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ if (pAllocateInfo->descriptorSetCount)
+ {
+ uint64_t* cgen_var_415;
+ stream->alloc((void**)&cgen_var_415, pAllocateInfo->descriptorSetCount * 8);
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_415, pAllocateInfo->descriptorSetCount);
+ stream->write((uint64_t*)cgen_var_415, pAllocateInfo->descriptorSetCount * 8);
+ }
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ if (pAllocateInfo->descriptorSetCount)
+ {
+ uint64_t* cgen_var_416;
+ stream->alloc((void**)&cgen_var_416, pAllocateInfo->descriptorSetCount * 8);
+ stream->read((uint64_t*)cgen_var_416, pAllocateInfo->descriptorSetCount * 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_416, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
+ }
+ stream->unsetHandleMapping();
+ VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
+ stream->read(&vkAllocateDescriptorSets_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkAllocateDescriptorSets_VkResult_return;
+}
+
+VkResult VkEncoder::vkFreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorPool local_descriptorPool;
+ uint32_t local_descriptorSetCount;
+ VkDescriptorSet* local_pDescriptorSets;
+ local_device = device;
+ local_descriptorPool = descriptorPool;
+ local_descriptorSetCount = descriptorSetCount;
+ local_pDescriptorSets = nullptr;
+ if (pDescriptorSets)
+ {
+ local_pDescriptorSets = (VkDescriptorSet*)pool->dupArray(pDescriptorSets, ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_417;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_417, 1);
+ countingStream->write((uint64_t*)&cgen_var_417, 1 * 8);
+ uint64_t cgen_var_418;
+ countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_418, 1);
+ countingStream->write((uint64_t*)&cgen_var_418, 1 * 8);
+ countingStream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_419 = (uint64_t)(uintptr_t)local_pDescriptorSets;
+ countingStream->putBe64(cgen_var_419);
+ if (local_pDescriptorSets)
+ {
+ if (((descriptorSetCount)))
+ {
+ uint64_t* cgen_var_420;
+ countingStream->alloc((void**)&cgen_var_420, ((descriptorSetCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_420, ((descriptorSetCount)));
+ countingStream->write((uint64_t*)cgen_var_420, ((descriptorSetCount)) * 8);
+ }
+ }
+ }
+ uint32_t packetSize_vkFreeDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkFreeDescriptorSets = OP_vkFreeDescriptorSets;
+ stream->write(&opcode_vkFreeDescriptorSets, sizeof(uint32_t));
+ stream->write(&packetSize_vkFreeDescriptorSets, sizeof(uint32_t));
+ uint64_t cgen_var_421;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_421, 1);
+ stream->write((uint64_t*)&cgen_var_421, 1 * 8);
+ uint64_t cgen_var_422;
+ stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_422, 1);
+ stream->write((uint64_t*)&cgen_var_422, 1 * 8);
+ stream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_423 = (uint64_t)(uintptr_t)local_pDescriptorSets;
+ stream->putBe64(cgen_var_423);
+ if (local_pDescriptorSets)
+ {
+ if (((descriptorSetCount)))
+ {
+ uint64_t* cgen_var_424;
+ stream->alloc((void**)&cgen_var_424, ((descriptorSetCount)) * 8);
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_424, ((descriptorSetCount)));
+ stream->write((uint64_t*)cgen_var_424, ((descriptorSetCount)) * 8);
+ }
+ }
+ VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
+ stream->read(&vkFreeDescriptorSets_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ if (pDescriptorSets)
+ {
+ resources->destroyMapping()->mapHandles_VkDescriptorSet((VkDescriptorSet*)pDescriptorSets, ((descriptorSetCount)));
+ }
+ return vkFreeDescriptorSets_VkResult_return;
+}
+
+void VkEncoder::vkUpdateDescriptorSets(
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_descriptorWriteCount;
+ VkWriteDescriptorSet* local_pDescriptorWrites;
+ uint32_t local_descriptorCopyCount;
+ VkCopyDescriptorSet* local_pDescriptorCopies;
+ local_device = device;
+ local_descriptorWriteCount = descriptorWriteCount;
+ local_pDescriptorWrites = nullptr;
+ if (pDescriptorWrites)
+ {
+ local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+ {
+ deepcopy_VkWriteDescriptorSet(pool, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ }
+ }
+ local_descriptorCopyCount = descriptorCopyCount;
+ local_pDescriptorCopies = nullptr;
+ if (pDescriptorCopies)
+ {
+ local_pDescriptorCopies = (VkCopyDescriptorSet*)pool->alloc(((descriptorCopyCount)) * sizeof(const VkCopyDescriptorSet));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
+ {
+ deepcopy_VkCopyDescriptorSet(pool, pDescriptorCopies + i, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_425;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_425, 1);
+ countingStream->write((uint64_t*)&cgen_var_425, 1 * 8);
+ countingStream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+ {
+ marshal_VkWriteDescriptorSet(countingStream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ }
+ countingStream->write((uint32_t*)&local_descriptorCopyCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
+ {
+ marshal_VkCopyDescriptorSet(countingStream, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+ }
+ }
+ uint32_t packetSize_vkUpdateDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkUpdateDescriptorSets = OP_vkUpdateDescriptorSets;
+ stream->write(&opcode_vkUpdateDescriptorSets, sizeof(uint32_t));
+ stream->write(&packetSize_vkUpdateDescriptorSets, sizeof(uint32_t));
+ uint64_t cgen_var_426;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_426, 1);
+ stream->write((uint64_t*)&cgen_var_426, 1 * 8);
+ stream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+ {
+ marshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ }
+ stream->write((uint32_t*)&local_descriptorCopyCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
+ {
+ marshal_VkCopyDescriptorSet(stream, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+ }
+}
+
+VkResult VkEncoder::vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkFramebufferCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkFramebufferCreateInfo*)pool->alloc(sizeof(const VkFramebufferCreateInfo));
+ deepcopy_VkFramebufferCreateInfo(pool, pCreateInfo, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_427;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_427, 1);
+ countingStream->write((uint64_t*)&cgen_var_427, 1 * 8);
+ marshal_VkFramebufferCreateInfo(countingStream, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_428 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_428);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_429;
+ countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_429, 1);
+ countingStream->write((uint64_t*)&cgen_var_429, 8);
+ }
+ uint32_t packetSize_vkCreateFramebuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateFramebuffer = OP_vkCreateFramebuffer;
+ stream->write(&opcode_vkCreateFramebuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateFramebuffer, sizeof(uint32_t));
+ uint64_t cgen_var_430;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_430, 1);
+ stream->write((uint64_t*)&cgen_var_430, 1 * 8);
+ marshal_VkFramebufferCreateInfo(stream, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_431 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_431);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_432;
+ stream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_432, 1);
+ stream->write((uint64_t*)&cgen_var_432, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_433;
+ stream->read((uint64_t*)&cgen_var_433, 8);
+ stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_433, (VkFramebuffer*)pFramebuffer, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateFramebuffer_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateFramebuffer_VkResult_return;
+}
+
+void VkEncoder::vkDestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkFramebuffer local_framebuffer;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_framebuffer = framebuffer;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_434;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_434, 1);
+ countingStream->write((uint64_t*)&cgen_var_434, 1 * 8);
+ uint64_t cgen_var_435;
+ countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_435, 1);
+ countingStream->write((uint64_t*)&cgen_var_435, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_436 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_436);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyFramebuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyFramebuffer = OP_vkDestroyFramebuffer;
+ stream->write(&opcode_vkDestroyFramebuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyFramebuffer, sizeof(uint32_t));
+ uint64_t cgen_var_437;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_437, 1);
+ stream->write((uint64_t*)&cgen_var_437, 1 * 8);
+ uint64_t cgen_var_438;
+ stream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_438, 1);
+ stream->write((uint64_t*)&cgen_var_438, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_439 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_439);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)&framebuffer);
+}
+
+VkResult VkEncoder::vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkRenderPassCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkRenderPassCreateInfo*)pool->alloc(sizeof(const VkRenderPassCreateInfo));
+ deepcopy_VkRenderPassCreateInfo(pool, pCreateInfo, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_440;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_440, 1);
+ countingStream->write((uint64_t*)&cgen_var_440, 1 * 8);
+ marshal_VkRenderPassCreateInfo(countingStream, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_441 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_441);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_442;
+ countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_442, 1);
+ countingStream->write((uint64_t*)&cgen_var_442, 8);
+ }
+ uint32_t packetSize_vkCreateRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateRenderPass = OP_vkCreateRenderPass;
+ stream->write(&opcode_vkCreateRenderPass, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateRenderPass, sizeof(uint32_t));
+ uint64_t cgen_var_443;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_443, 1);
+ stream->write((uint64_t*)&cgen_var_443, 1 * 8);
+ marshal_VkRenderPassCreateInfo(stream, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_444 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_444);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_445;
+ stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_445, 1);
+ stream->write((uint64_t*)&cgen_var_445, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_446;
+ stream->read((uint64_t*)&cgen_var_446, 8);
+ stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_446, (VkRenderPass*)pRenderPass, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateRenderPass_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateRenderPass_VkResult_return;
+}
+
+void VkEncoder::vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkRenderPass local_renderPass;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_renderPass = renderPass;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_447;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_447, 1);
+ countingStream->write((uint64_t*)&cgen_var_447, 1 * 8);
+ uint64_t cgen_var_448;
+ countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_448, 1);
+ countingStream->write((uint64_t*)&cgen_var_448, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_449 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_449);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyRenderPass = OP_vkDestroyRenderPass;
+ stream->write(&opcode_vkDestroyRenderPass, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyRenderPass, sizeof(uint32_t));
+ uint64_t cgen_var_450;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_450, 1);
+ stream->write((uint64_t*)&cgen_var_450, 1 * 8);
+ uint64_t cgen_var_451;
+ stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_451, 1);
+ stream->write((uint64_t*)&cgen_var_451, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_452 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_452);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkRenderPass((VkRenderPass*)&renderPass);
+}
+
+void VkEncoder::vkGetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkRenderPass local_renderPass;
+ local_device = device;
+ local_renderPass = renderPass;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_453;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_453, 1);
+ countingStream->write((uint64_t*)&cgen_var_453, 1 * 8);
+ uint64_t cgen_var_454;
+ countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_454, 1);
+ countingStream->write((uint64_t*)&cgen_var_454, 1 * 8);
+ marshal_VkExtent2D(countingStream, (VkExtent2D*)(pGranularity));
+ }
+ uint32_t packetSize_vkGetRenderAreaGranularity = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetRenderAreaGranularity = OP_vkGetRenderAreaGranularity;
+ stream->write(&opcode_vkGetRenderAreaGranularity, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetRenderAreaGranularity, sizeof(uint32_t));
+ uint64_t cgen_var_455;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_455, 1);
+ stream->write((uint64_t*)&cgen_var_455, 1 * 8);
+ uint64_t cgen_var_456;
+ stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_456, 1);
+ stream->write((uint64_t*)&cgen_var_456, 1 * 8);
+ marshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
+ unmarshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
+}
+
+VkResult VkEncoder::vkCreateCommandPool(
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkCommandPoolCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkCommandPoolCreateInfo*)pool->alloc(sizeof(const VkCommandPoolCreateInfo));
+ deepcopy_VkCommandPoolCreateInfo(pool, pCreateInfo, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_457;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_457, 1);
+ countingStream->write((uint64_t*)&cgen_var_457, 1 * 8);
+ marshal_VkCommandPoolCreateInfo(countingStream, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_458 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_458);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_459;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_459, 1);
+ countingStream->write((uint64_t*)&cgen_var_459, 8);
+ }
+ uint32_t packetSize_vkCreateCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateCommandPool = OP_vkCreateCommandPool;
+ stream->write(&opcode_vkCreateCommandPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateCommandPool, sizeof(uint32_t));
+ uint64_t cgen_var_460;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_460, 1);
+ stream->write((uint64_t*)&cgen_var_460, 1 * 8);
+ marshal_VkCommandPoolCreateInfo(stream, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_461 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_461);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_462;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_462, 1);
+ stream->write((uint64_t*)&cgen_var_462, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_463;
+ stream->read((uint64_t*)&cgen_var_463, 8);
+ stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_463, (VkCommandPool*)pCommandPool, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateCommandPool_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateCommandPool_VkResult_return;
+}
+
+void VkEncoder::vkDestroyCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkCommandPool local_commandPool;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_commandPool = commandPool;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_464;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_464, 1);
+ countingStream->write((uint64_t*)&cgen_var_464, 1 * 8);
+ uint64_t cgen_var_465;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_465, 1);
+ countingStream->write((uint64_t*)&cgen_var_465, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_466 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_466);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyCommandPool = OP_vkDestroyCommandPool;
+ stream->write(&opcode_vkDestroyCommandPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyCommandPool, sizeof(uint32_t));
+ uint64_t cgen_var_467;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_467, 1);
+ stream->write((uint64_t*)&cgen_var_467, 1 * 8);
+ uint64_t cgen_var_468;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_468, 1);
+ stream->write((uint64_t*)&cgen_var_468, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_469 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_469);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkCommandPool((VkCommandPool*)&commandPool);
+}
+
+VkResult VkEncoder::vkResetCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkCommandPool local_commandPool;
+ VkCommandPoolResetFlags local_flags;
+ local_device = device;
+ local_commandPool = commandPool;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_470;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_470, 1);
+ countingStream->write((uint64_t*)&cgen_var_470, 1 * 8);
+ uint64_t cgen_var_471;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_471, 1);
+ countingStream->write((uint64_t*)&cgen_var_471, 1 * 8);
+ countingStream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
+ }
+ uint32_t packetSize_vkResetCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkResetCommandPool = OP_vkResetCommandPool;
+ stream->write(&opcode_vkResetCommandPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkResetCommandPool, sizeof(uint32_t));
+ uint64_t cgen_var_472;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_472, 1);
+ stream->write((uint64_t*)&cgen_var_472, 1 * 8);
+ uint64_t cgen_var_473;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_473, 1);
+ stream->write((uint64_t*)&cgen_var_473, 1 * 8);
+ stream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
+ VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
+ stream->read(&vkResetCommandPool_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkResetCommandPool_VkResult_return;
+}
+
+VkResult VkEncoder::vkAllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkCommandBufferAllocateInfo* local_pAllocateInfo;
+ local_device = device;
+ local_pAllocateInfo = nullptr;
+ if (pAllocateInfo)
+ {
+ local_pAllocateInfo = (VkCommandBufferAllocateInfo*)pool->alloc(sizeof(const VkCommandBufferAllocateInfo));
+ deepcopy_VkCommandBufferAllocateInfo(pool, pAllocateInfo, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_474;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_474, 1);
+ countingStream->write((uint64_t*)&cgen_var_474, 1 * 8);
+ marshal_VkCommandBufferAllocateInfo(countingStream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+ if (pAllocateInfo->commandBufferCount)
+ {
+ uint64_t* cgen_var_475;
+ countingStream->alloc((void**)&cgen_var_475, pAllocateInfo->commandBufferCount * 8);
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_475, pAllocateInfo->commandBufferCount);
+ countingStream->write((uint64_t*)cgen_var_475, pAllocateInfo->commandBufferCount * 8);
+ }
+ }
+ uint32_t packetSize_vkAllocateCommandBuffers = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkAllocateCommandBuffers = OP_vkAllocateCommandBuffers;
+ stream->write(&opcode_vkAllocateCommandBuffers, sizeof(uint32_t));
+ stream->write(&packetSize_vkAllocateCommandBuffers, sizeof(uint32_t));
+ uint64_t cgen_var_476;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_476, 1);
+ stream->write((uint64_t*)&cgen_var_476, 1 * 8);
+ marshal_VkCommandBufferAllocateInfo(stream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ if (pAllocateInfo->commandBufferCount)
+ {
+ uint64_t* cgen_var_477;
+ stream->alloc((void**)&cgen_var_477, pAllocateInfo->commandBufferCount * 8);
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_477, pAllocateInfo->commandBufferCount);
+ stream->write((uint64_t*)cgen_var_477, pAllocateInfo->commandBufferCount * 8);
+ }
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ if (pAllocateInfo->commandBufferCount)
+ {
+ uint64_t* cgen_var_478;
+ stream->alloc((void**)&cgen_var_478, pAllocateInfo->commandBufferCount * 8);
+ stream->read((uint64_t*)cgen_var_478, pAllocateInfo->commandBufferCount * 8);
+ stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_478, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
+ }
+ stream->unsetHandleMapping();
+ VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
+ stream->read(&vkAllocateCommandBuffers_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkAllocateCommandBuffers_VkResult_return;
+}
+
+void VkEncoder::vkFreeCommandBuffers(
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkCommandPool local_commandPool;
+ uint32_t local_commandBufferCount;
+ VkCommandBuffer* local_pCommandBuffers;
+ local_device = device;
+ local_commandPool = commandPool;
+ local_commandBufferCount = commandBufferCount;
+ local_pCommandBuffers = nullptr;
+ if (pCommandBuffers)
+ {
+ local_pCommandBuffers = (VkCommandBuffer*)pool->dupArray(pCommandBuffers, ((commandBufferCount)) * sizeof(const VkCommandBuffer));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_479;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_479, 1);
+ countingStream->write((uint64_t*)&cgen_var_479, 1 * 8);
+ uint64_t cgen_var_480;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_480, 1);
+ countingStream->write((uint64_t*)&cgen_var_480, 1 * 8);
+ countingStream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_481 = (uint64_t)(uintptr_t)local_pCommandBuffers;
+ countingStream->putBe64(cgen_var_481);
+ if (local_pCommandBuffers)
+ {
+ if (((commandBufferCount)))
+ {
+ uint64_t* cgen_var_482;
+ countingStream->alloc((void**)&cgen_var_482, ((commandBufferCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_482, ((commandBufferCount)));
+ countingStream->write((uint64_t*)cgen_var_482, ((commandBufferCount)) * 8);
+ }
+ }
+ }
+ uint32_t packetSize_vkFreeCommandBuffers = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkFreeCommandBuffers = OP_vkFreeCommandBuffers;
+ stream->write(&opcode_vkFreeCommandBuffers, sizeof(uint32_t));
+ stream->write(&packetSize_vkFreeCommandBuffers, sizeof(uint32_t));
+ uint64_t cgen_var_483;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_483, 1);
+ stream->write((uint64_t*)&cgen_var_483, 1 * 8);
+ uint64_t cgen_var_484;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_484, 1);
+ stream->write((uint64_t*)&cgen_var_484, 1 * 8);
+ stream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_485 = (uint64_t)(uintptr_t)local_pCommandBuffers;
+ stream->putBe64(cgen_var_485);
+ if (local_pCommandBuffers)
+ {
+ if (((commandBufferCount)))
+ {
+ uint64_t* cgen_var_486;
+ stream->alloc((void**)&cgen_var_486, ((commandBufferCount)) * 8);
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_486, ((commandBufferCount)));
+ stream->write((uint64_t*)cgen_var_486, ((commandBufferCount)) * 8);
+ }
+ }
+ if (pCommandBuffers)
+ {
+ resources->destroyMapping()->mapHandles_VkCommandBuffer((VkCommandBuffer*)pCommandBuffers, ((commandBufferCount)));
+ }
+}
+
+VkResult VkEncoder::vkBeginCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkCommandBufferBeginInfo* local_pBeginInfo;
+ local_commandBuffer = commandBuffer;
+ local_pBeginInfo = nullptr;
+ if (pBeginInfo)
+ {
+ local_pBeginInfo = (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
+ deepcopy_VkCommandBufferBeginInfo(pool, pBeginInfo, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_487;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_487, 1);
+ countingStream->write((uint64_t*)&cgen_var_487, 1 * 8);
+ marshal_VkCommandBufferBeginInfo(countingStream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ }
+ uint32_t packetSize_vkBeginCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkBeginCommandBuffer = OP_vkBeginCommandBuffer;
+ stream->write(&opcode_vkBeginCommandBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkBeginCommandBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_488;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_488, 1);
+ stream->write((uint64_t*)&cgen_var_488, 1 * 8);
+ marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
+ stream->read(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkBeginCommandBuffer_VkResult_return;
+}
+
+VkResult VkEncoder::vkEndCommandBuffer(
+ VkCommandBuffer commandBuffer)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ local_commandBuffer = commandBuffer;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_489;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_489, 1);
+ countingStream->write((uint64_t*)&cgen_var_489, 1 * 8);
+ }
+ uint32_t packetSize_vkEndCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkEndCommandBuffer = OP_vkEndCommandBuffer;
+ stream->write(&opcode_vkEndCommandBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkEndCommandBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_490;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_490, 1);
+ stream->write((uint64_t*)&cgen_var_490, 1 * 8);
+ VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
+ stream->read(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkEndCommandBuffer_VkResult_return;
+}
+
+VkResult VkEncoder::vkResetCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkCommandBufferResetFlags local_flags;
+ local_commandBuffer = commandBuffer;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_491;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_491, 1);
+ countingStream->write((uint64_t*)&cgen_var_491, 1 * 8);
+ countingStream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
+ }
+ uint32_t packetSize_vkResetCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkResetCommandBuffer = OP_vkResetCommandBuffer;
+ stream->write(&opcode_vkResetCommandBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkResetCommandBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_492;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_492, 1);
+ stream->write((uint64_t*)&cgen_var_492, 1 * 8);
+ stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
+ VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
+ stream->read(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkResetCommandBuffer_VkResult_return;
+}
+
+void VkEncoder::vkCmdBindPipeline(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkPipelineBindPoint local_pipelineBindPoint;
+ VkPipeline local_pipeline;
+ local_commandBuffer = commandBuffer;
+ local_pipelineBindPoint = pipelineBindPoint;
+ local_pipeline = pipeline;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_493;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_493, 1);
+ countingStream->write((uint64_t*)&cgen_var_493, 1 * 8);
+ countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ uint64_t cgen_var_494;
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_494, 1);
+ countingStream->write((uint64_t*)&cgen_var_494, 1 * 8);
+ }
+ uint32_t packetSize_vkCmdBindPipeline = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBindPipeline = OP_vkCmdBindPipeline;
+ stream->write(&opcode_vkCmdBindPipeline, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBindPipeline, sizeof(uint32_t));
+ uint64_t cgen_var_495;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_495, 1);
+ stream->write((uint64_t*)&cgen_var_495, 1 * 8);
+ stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ uint64_t cgen_var_496;
+ stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_496, 1);
+ stream->write((uint64_t*)&cgen_var_496, 1 * 8);
+}
+
+void VkEncoder::vkCmdSetViewport(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport* pViewports)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_firstViewport;
+ uint32_t local_viewportCount;
+ VkViewport* local_pViewports;
+ local_commandBuffer = commandBuffer;
+ local_firstViewport = firstViewport;
+ local_viewportCount = viewportCount;
+ local_pViewports = nullptr;
+ if (pViewports)
+ {
+ 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));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_497;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_497, 1);
+ countingStream->write((uint64_t*)&cgen_var_497, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+ {
+ marshal_VkViewport(countingStream, (VkViewport*)(local_pViewports + i));
+ }
+ }
+ uint32_t packetSize_vkCmdSetViewport = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetViewport = OP_vkCmdSetViewport;
+ stream->write(&opcode_vkCmdSetViewport, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetViewport, sizeof(uint32_t));
+ uint64_t cgen_var_498;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_498, 1);
+ stream->write((uint64_t*)&cgen_var_498, 1 * 8);
+ stream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+ {
+ marshal_VkViewport(stream, (VkViewport*)(local_pViewports + i));
+ }
+}
+
+void VkEncoder::vkCmdSetScissor(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_firstScissor;
+ uint32_t local_scissorCount;
+ VkRect2D* local_pScissors;
+ local_commandBuffer = commandBuffer;
+ local_firstScissor = firstScissor;
+ local_scissorCount = scissorCount;
+ local_pScissors = nullptr;
+ if (pScissors)
+ {
+ 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));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_499;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_499, 1);
+ countingStream->write((uint64_t*)&cgen_var_499, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstScissor, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_scissorCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
+ {
+ marshal_VkRect2D(countingStream, (VkRect2D*)(local_pScissors + i));
+ }
+ }
+ uint32_t packetSize_vkCmdSetScissor = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetScissor = OP_vkCmdSetScissor;
+ stream->write(&opcode_vkCmdSetScissor, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetScissor, sizeof(uint32_t));
+ uint64_t cgen_var_500;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_500, 1);
+ stream->write((uint64_t*)&cgen_var_500, 1 * 8);
+ stream->write((uint32_t*)&local_firstScissor, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_scissorCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
+ {
+ marshal_VkRect2D(stream, (VkRect2D*)(local_pScissors + i));
+ }
+}
+
+void VkEncoder::vkCmdSetLineWidth(
+ VkCommandBuffer commandBuffer,
+ float lineWidth)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ float local_lineWidth;
+ local_commandBuffer = commandBuffer;
+ local_lineWidth = lineWidth;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_501;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_501, 1);
+ countingStream->write((uint64_t*)&cgen_var_501, 1 * 8);
+ countingStream->write((float*)&local_lineWidth, sizeof(float));
+ }
+ uint32_t packetSize_vkCmdSetLineWidth = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetLineWidth = OP_vkCmdSetLineWidth;
+ stream->write(&opcode_vkCmdSetLineWidth, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetLineWidth, sizeof(uint32_t));
+ uint64_t cgen_var_502;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_502, 1);
+ stream->write((uint64_t*)&cgen_var_502, 1 * 8);
+ stream->write((float*)&local_lineWidth, sizeof(float));
+}
+
+void VkEncoder::vkCmdSetDepthBias(
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ float local_depthBiasConstantFactor;
+ float local_depthBiasClamp;
+ float local_depthBiasSlopeFactor;
+ local_commandBuffer = commandBuffer;
+ local_depthBiasConstantFactor = depthBiasConstantFactor;
+ local_depthBiasClamp = depthBiasClamp;
+ local_depthBiasSlopeFactor = depthBiasSlopeFactor;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_503;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_503, 1);
+ countingStream->write((uint64_t*)&cgen_var_503, 1 * 8);
+ countingStream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
+ countingStream->write((float*)&local_depthBiasClamp, sizeof(float));
+ countingStream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
+ }
+ uint32_t packetSize_vkCmdSetDepthBias = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetDepthBias = OP_vkCmdSetDepthBias;
+ stream->write(&opcode_vkCmdSetDepthBias, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetDepthBias, sizeof(uint32_t));
+ uint64_t cgen_var_504;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_504, 1);
+ stream->write((uint64_t*)&cgen_var_504, 1 * 8);
+ stream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
+ stream->write((float*)&local_depthBiasClamp, sizeof(float));
+ stream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
+}
+
+void VkEncoder::vkCmdSetBlendConstants(
+ VkCommandBuffer commandBuffer,
+ const float blendConstants)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ float local_blendConstants[4];
+ local_commandBuffer = commandBuffer;
+ memcpy(&local_blendConstants, &blendConstants, 4 * sizeof(const float));
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_505;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_505, 1);
+ countingStream->write((uint64_t*)&cgen_var_505, 1 * 8);
+ countingStream->write((float*)&local_blendConstants, 4 * sizeof(float));
+ }
+ uint32_t packetSize_vkCmdSetBlendConstants = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetBlendConstants = OP_vkCmdSetBlendConstants;
+ stream->write(&opcode_vkCmdSetBlendConstants, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetBlendConstants, sizeof(uint32_t));
+ uint64_t cgen_var_506;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_506, 1);
+ stream->write((uint64_t*)&cgen_var_506, 1 * 8);
+ stream->write((float*)&local_blendConstants, 4 * sizeof(float));
+}
+
+void VkEncoder::vkCmdSetDepthBounds(
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ float local_minDepthBounds;
+ float local_maxDepthBounds;
+ local_commandBuffer = commandBuffer;
+ local_minDepthBounds = minDepthBounds;
+ local_maxDepthBounds = maxDepthBounds;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_507;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_507, 1);
+ countingStream->write((uint64_t*)&cgen_var_507, 1 * 8);
+ countingStream->write((float*)&local_minDepthBounds, sizeof(float));
+ countingStream->write((float*)&local_maxDepthBounds, sizeof(float));
+ }
+ uint32_t packetSize_vkCmdSetDepthBounds = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetDepthBounds = OP_vkCmdSetDepthBounds;
+ stream->write(&opcode_vkCmdSetDepthBounds, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetDepthBounds, sizeof(uint32_t));
+ uint64_t cgen_var_508;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_508, 1);
+ stream->write((uint64_t*)&cgen_var_508, 1 * 8);
+ stream->write((float*)&local_minDepthBounds, sizeof(float));
+ stream->write((float*)&local_maxDepthBounds, sizeof(float));
+}
+
+void VkEncoder::vkCmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkStencilFaceFlags local_faceMask;
+ uint32_t local_compareMask;
+ local_commandBuffer = commandBuffer;
+ local_faceMask = faceMask;
+ local_compareMask = compareMask;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_509;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_509, 1);
+ countingStream->write((uint64_t*)&cgen_var_509, 1 * 8);
+ countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+ countingStream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdSetStencilCompareMask = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetStencilCompareMask = OP_vkCmdSetStencilCompareMask;
+ stream->write(&opcode_vkCmdSetStencilCompareMask, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetStencilCompareMask, sizeof(uint32_t));
+ uint64_t cgen_var_510;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_510, 1);
+ stream->write((uint64_t*)&cgen_var_510, 1 * 8);
+ stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+ stream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkStencilFaceFlags local_faceMask;
+ uint32_t local_writeMask;
+ local_commandBuffer = commandBuffer;
+ local_faceMask = faceMask;
+ local_writeMask = writeMask;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_511;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_511, 1);
+ countingStream->write((uint64_t*)&cgen_var_511, 1 * 8);
+ countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+ countingStream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdSetStencilWriteMask = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetStencilWriteMask = OP_vkCmdSetStencilWriteMask;
+ stream->write(&opcode_vkCmdSetStencilWriteMask, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetStencilWriteMask, sizeof(uint32_t));
+ uint64_t cgen_var_512;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_512, 1);
+ stream->write((uint64_t*)&cgen_var_512, 1 * 8);
+ stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+ stream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkStencilFaceFlags local_faceMask;
+ uint32_t local_reference;
+ local_commandBuffer = commandBuffer;
+ local_faceMask = faceMask;
+ local_reference = reference;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_513;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_513, 1);
+ countingStream->write((uint64_t*)&cgen_var_513, 1 * 8);
+ countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+ countingStream->write((uint32_t*)&local_reference, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdSetStencilReference = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetStencilReference = OP_vkCmdSetStencilReference;
+ stream->write(&opcode_vkCmdSetStencilReference, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetStencilReference, sizeof(uint32_t));
+ uint64_t cgen_var_514;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_514, 1);
+ stream->write((uint64_t*)&cgen_var_514, 1 * 8);
+ stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
+ stream->write((uint32_t*)&local_reference, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkPipelineBindPoint local_pipelineBindPoint;
+ VkPipelineLayout local_layout;
+ uint32_t local_firstSet;
+ uint32_t local_descriptorSetCount;
+ VkDescriptorSet* local_pDescriptorSets;
+ uint32_t local_dynamicOffsetCount;
+ uint32_t* local_pDynamicOffsets;
+ local_commandBuffer = commandBuffer;
+ local_pipelineBindPoint = pipelineBindPoint;
+ local_layout = layout;
+ local_firstSet = firstSet;
+ local_descriptorSetCount = descriptorSetCount;
+ local_pDescriptorSets = nullptr;
+ if (pDescriptorSets)
+ {
+ local_pDescriptorSets = (VkDescriptorSet*)pool->dupArray(pDescriptorSets, ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
+ }
+ local_dynamicOffsetCount = dynamicOffsetCount;
+ local_pDynamicOffsets = nullptr;
+ if (pDynamicOffsets)
+ {
+ local_pDynamicOffsets = (uint32_t*)pool->dupArray(pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(const uint32_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_515;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_515, 1);
+ countingStream->write((uint64_t*)&cgen_var_515, 1 * 8);
+ countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ uint64_t cgen_var_516;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_516, 1);
+ countingStream->write((uint64_t*)&cgen_var_516, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstSet, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
+ if (((descriptorSetCount)))
+ {
+ uint64_t* cgen_var_517;
+ countingStream->alloc((void**)&cgen_var_517, ((descriptorSetCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_517, ((descriptorSetCount)));
+ countingStream->write((uint64_t*)cgen_var_517, ((descriptorSetCount)) * 8);
+ }
+ countingStream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdBindDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBindDescriptorSets = OP_vkCmdBindDescriptorSets;
+ stream->write(&opcode_vkCmdBindDescriptorSets, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBindDescriptorSets, sizeof(uint32_t));
+ uint64_t cgen_var_518;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_518, 1);
+ stream->write((uint64_t*)&cgen_var_518, 1 * 8);
+ stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ uint64_t cgen_var_519;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_519, 1);
+ stream->write((uint64_t*)&cgen_var_519, 1 * 8);
+ stream->write((uint32_t*)&local_firstSet, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
+ if (((descriptorSetCount)))
+ {
+ uint64_t* cgen_var_520;
+ stream->alloc((void**)&cgen_var_520, ((descriptorSetCount)) * 8);
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_520, ((descriptorSetCount)));
+ stream->write((uint64_t*)cgen_var_520, ((descriptorSetCount)) * 8);
+ }
+ stream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
+ stream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdBindIndexBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ VkIndexType local_indexType;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_indexType = indexType;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_521;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_521, 1);
+ countingStream->write((uint64_t*)&cgen_var_521, 1 * 8);
+ uint64_t cgen_var_522;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_522, 1);
+ countingStream->write((uint64_t*)&cgen_var_522, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ countingStream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
+ }
+ uint32_t packetSize_vkCmdBindIndexBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBindIndexBuffer = OP_vkCmdBindIndexBuffer;
+ stream->write(&opcode_vkCmdBindIndexBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBindIndexBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_523;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_523, 1);
+ stream->write((uint64_t*)&cgen_var_523, 1 * 8);
+ uint64_t cgen_var_524;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_524, 1);
+ stream->write((uint64_t*)&cgen_var_524, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ stream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
+}
+
+void VkEncoder::vkCmdBindVertexBuffers(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_firstBinding;
+ uint32_t local_bindingCount;
+ VkBuffer* local_pBuffers;
+ VkDeviceSize* local_pOffsets;
+ local_commandBuffer = commandBuffer;
+ local_firstBinding = firstBinding;
+ local_bindingCount = bindingCount;
+ local_pBuffers = nullptr;
+ if (pBuffers)
+ {
+ local_pBuffers = (VkBuffer*)pool->dupArray(pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
+ }
+ local_pOffsets = nullptr;
+ if (pOffsets)
+ {
+ local_pOffsets = (VkDeviceSize*)pool->dupArray(pOffsets, ((bindingCount)) * sizeof(const VkDeviceSize));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_525;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_525, 1);
+ countingStream->write((uint64_t*)&cgen_var_525, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstBinding, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_bindingCount, sizeof(uint32_t));
+ if (((bindingCount)))
+ {
+ uint64_t* cgen_var_526;
+ countingStream->alloc((void**)&cgen_var_526, ((bindingCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_526, ((bindingCount)));
+ countingStream->write((uint64_t*)cgen_var_526, ((bindingCount)) * 8);
+ }
+ countingStream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
+ }
+ uint32_t packetSize_vkCmdBindVertexBuffers = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBindVertexBuffers = OP_vkCmdBindVertexBuffers;
+ stream->write(&opcode_vkCmdBindVertexBuffers, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBindVertexBuffers, sizeof(uint32_t));
+ uint64_t cgen_var_527;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_527, 1);
+ stream->write((uint64_t*)&cgen_var_527, 1 * 8);
+ stream->write((uint32_t*)&local_firstBinding, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_bindingCount, sizeof(uint32_t));
+ if (((bindingCount)))
+ {
+ uint64_t* cgen_var_528;
+ stream->alloc((void**)&cgen_var_528, ((bindingCount)) * 8);
+ stream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_528, ((bindingCount)));
+ stream->write((uint64_t*)cgen_var_528, ((bindingCount)) * 8);
+ }
+ stream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
+}
+
+void VkEncoder::vkCmdDraw(
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_vertexCount;
+ uint32_t local_instanceCount;
+ uint32_t local_firstVertex;
+ uint32_t local_firstInstance;
+ local_commandBuffer = commandBuffer;
+ local_vertexCount = vertexCount;
+ local_instanceCount = instanceCount;
+ local_firstVertex = firstVertex;
+ local_firstInstance = firstInstance;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_529;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_529, 1);
+ countingStream->write((uint64_t*)&cgen_var_529, 1 * 8);
+ countingStream->write((uint32_t*)&local_vertexCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDraw = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDraw = OP_vkCmdDraw;
+ stream->write(&opcode_vkCmdDraw, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDraw, sizeof(uint32_t));
+ uint64_t cgen_var_530;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_530, 1);
+ stream->write((uint64_t*)&cgen_var_530, 1 * 8);
+ stream->write((uint32_t*)&local_vertexCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndexed(
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_indexCount;
+ uint32_t local_instanceCount;
+ uint32_t local_firstIndex;
+ int32_t local_vertexOffset;
+ uint32_t local_firstInstance;
+ local_commandBuffer = commandBuffer;
+ local_indexCount = indexCount;
+ local_instanceCount = instanceCount;
+ local_firstIndex = firstIndex;
+ local_vertexOffset = vertexOffset;
+ local_firstInstance = firstInstance;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_531;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_531, 1);
+ countingStream->write((uint64_t*)&cgen_var_531, 1 * 8);
+ countingStream->write((uint32_t*)&local_indexCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
+ countingStream->write((int32_t*)&local_vertexOffset, sizeof(int32_t));
+ countingStream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDrawIndexed = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDrawIndexed = OP_vkCmdDrawIndexed;
+ stream->write(&opcode_vkCmdDrawIndexed, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndexed, sizeof(uint32_t));
+ uint64_t cgen_var_532;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_532, 1);
+ stream->write((uint64_t*)&cgen_var_532, 1 * 8);
+ stream->write((uint32_t*)&local_indexCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
+ stream->write((int32_t*)&local_vertexOffset, sizeof(int32_t));
+ stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ uint32_t local_drawCount;
+ uint32_t local_stride;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_drawCount = drawCount;
+ local_stride = stride;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_533;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_533, 1);
+ countingStream->write((uint64_t*)&cgen_var_533, 1 * 8);
+ uint64_t cgen_var_534;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_534, 1);
+ countingStream->write((uint64_t*)&cgen_var_534, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDrawIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDrawIndirect = OP_vkCmdDrawIndirect;
+ stream->write(&opcode_vkCmdDrawIndirect, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndirect, sizeof(uint32_t));
+ uint64_t cgen_var_535;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_535, 1);
+ stream->write((uint64_t*)&cgen_var_535, 1 * 8);
+ uint64_t cgen_var_536;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_536, 1);
+ stream->write((uint64_t*)&cgen_var_536, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ uint32_t local_drawCount;
+ uint32_t local_stride;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_drawCount = drawCount;
+ local_stride = stride;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_537;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_537, 1);
+ countingStream->write((uint64_t*)&cgen_var_537, 1 * 8);
+ uint64_t cgen_var_538;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_538, 1);
+ countingStream->write((uint64_t*)&cgen_var_538, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDrawIndexedIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDrawIndexedIndirect = OP_vkCmdDrawIndexedIndirect;
+ stream->write(&opcode_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+ uint64_t cgen_var_539;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_539, 1);
+ stream->write((uint64_t*)&cgen_var_539, 1 * 8);
+ uint64_t cgen_var_540;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_540, 1);
+ stream->write((uint64_t*)&cgen_var_540, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDispatch(
+ VkCommandBuffer commandBuffer,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_groupCountX;
+ uint32_t local_groupCountY;
+ uint32_t local_groupCountZ;
+ local_commandBuffer = commandBuffer;
+ local_groupCountX = groupCountX;
+ local_groupCountY = groupCountY;
+ local_groupCountZ = groupCountZ;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_541;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_541, 1);
+ countingStream->write((uint64_t*)&cgen_var_541, 1 * 8);
+ countingStream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDispatch = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDispatch = OP_vkCmdDispatch;
+ stream->write(&opcode_vkCmdDispatch, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDispatch, sizeof(uint32_t));
+ uint64_t cgen_var_542;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_542, 1);
+ stream->write((uint64_t*)&cgen_var_542, 1 * 8);
+ stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDispatchIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_543;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_543, 1);
+ countingStream->write((uint64_t*)&cgen_var_543, 1 * 8);
+ uint64_t cgen_var_544;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_544, 1);
+ countingStream->write((uint64_t*)&cgen_var_544, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ }
+ uint32_t packetSize_vkCmdDispatchIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDispatchIndirect = OP_vkCmdDispatchIndirect;
+ stream->write(&opcode_vkCmdDispatchIndirect, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDispatchIndirect, sizeof(uint32_t));
+ uint64_t cgen_var_545;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_545, 1);
+ stream->write((uint64_t*)&cgen_var_545, 1 * 8);
+ uint64_t cgen_var_546;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_546, 1);
+ stream->write((uint64_t*)&cgen_var_546, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+}
+
+void VkEncoder::vkCmdCopyBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_srcBuffer;
+ VkBuffer local_dstBuffer;
+ uint32_t local_regionCount;
+ VkBufferCopy* local_pRegions;
+ local_commandBuffer = commandBuffer;
+ local_srcBuffer = srcBuffer;
+ local_dstBuffer = dstBuffer;
+ local_regionCount = regionCount;
+ local_pRegions = nullptr;
+ if (pRegions)
+ {
+ 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));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_547;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_547, 1);
+ countingStream->write((uint64_t*)&cgen_var_547, 1 * 8);
+ uint64_t cgen_var_548;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_548, 1);
+ countingStream->write((uint64_t*)&cgen_var_548, 1 * 8);
+ uint64_t cgen_var_549;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_549, 1);
+ countingStream->write((uint64_t*)&cgen_var_549, 1 * 8);
+ countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkBufferCopy(countingStream, (VkBufferCopy*)(local_pRegions + i));
+ }
+ }
+ uint32_t packetSize_vkCmdCopyBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdCopyBuffer = OP_vkCmdCopyBuffer;
+ stream->write(&opcode_vkCmdCopyBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdCopyBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_550;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_550, 1);
+ stream->write((uint64_t*)&cgen_var_550, 1 * 8);
+ uint64_t cgen_var_551;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_551, 1);
+ stream->write((uint64_t*)&cgen_var_551, 1 * 8);
+ uint64_t cgen_var_552;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_552, 1);
+ stream->write((uint64_t*)&cgen_var_552, 1 * 8);
+ stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkBufferCopy(stream, (VkBufferCopy*)(local_pRegions + i));
+ }
+}
+
+void VkEncoder::vkCmdCopyImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkImage local_srcImage;
+ VkImageLayout local_srcImageLayout;
+ VkImage local_dstImage;
+ VkImageLayout local_dstImageLayout;
+ uint32_t local_regionCount;
+ VkImageCopy* local_pRegions;
+ local_commandBuffer = commandBuffer;
+ local_srcImage = srcImage;
+ local_srcImageLayout = srcImageLayout;
+ local_dstImage = dstImage;
+ local_dstImageLayout = dstImageLayout;
+ local_regionCount = regionCount;
+ local_pRegions = nullptr;
+ if (pRegions)
+ {
+ 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));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_553;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_553, 1);
+ countingStream->write((uint64_t*)&cgen_var_553, 1 * 8);
+ uint64_t cgen_var_554;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_554, 1);
+ countingStream->write((uint64_t*)&cgen_var_554, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_555;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_555, 1);
+ countingStream->write((uint64_t*)&cgen_var_555, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+ countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkImageCopy(countingStream, (VkImageCopy*)(local_pRegions + i));
+ }
+ }
+ uint32_t packetSize_vkCmdCopyImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdCopyImage = OP_vkCmdCopyImage;
+ stream->write(&opcode_vkCmdCopyImage, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdCopyImage, sizeof(uint32_t));
+ uint64_t cgen_var_556;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_556, 1);
+ stream->write((uint64_t*)&cgen_var_556, 1 * 8);
+ uint64_t cgen_var_557;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_557, 1);
+ stream->write((uint64_t*)&cgen_var_557, 1 * 8);
+ stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_558;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_558, 1);
+ stream->write((uint64_t*)&cgen_var_558, 1 * 8);
+ stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+ stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkImageCopy(stream, (VkImageCopy*)(local_pRegions + i));
+ }
+}
+
+void VkEncoder::vkCmdBlitImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkImage local_srcImage;
+ VkImageLayout local_srcImageLayout;
+ VkImage local_dstImage;
+ VkImageLayout local_dstImageLayout;
+ uint32_t local_regionCount;
+ VkImageBlit* local_pRegions;
+ VkFilter local_filter;
+ local_commandBuffer = commandBuffer;
+ local_srcImage = srcImage;
+ local_srcImageLayout = srcImageLayout;
+ local_dstImage = dstImage;
+ local_dstImageLayout = dstImageLayout;
+ local_regionCount = regionCount;
+ local_pRegions = nullptr;
+ if (pRegions)
+ {
+ 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));
+ }
+ }
+ local_filter = filter;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_559;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_559, 1);
+ countingStream->write((uint64_t*)&cgen_var_559, 1 * 8);
+ uint64_t cgen_var_560;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_560, 1);
+ countingStream->write((uint64_t*)&cgen_var_560, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_561;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_561, 1);
+ countingStream->write((uint64_t*)&cgen_var_561, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+ countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkImageBlit(countingStream, (VkImageBlit*)(local_pRegions + i));
+ }
+ countingStream->write((VkFilter*)&local_filter, sizeof(VkFilter));
+ }
+ uint32_t packetSize_vkCmdBlitImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBlitImage = OP_vkCmdBlitImage;
+ stream->write(&opcode_vkCmdBlitImage, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBlitImage, sizeof(uint32_t));
+ uint64_t cgen_var_562;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_562, 1);
+ stream->write((uint64_t*)&cgen_var_562, 1 * 8);
+ uint64_t cgen_var_563;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_563, 1);
+ stream->write((uint64_t*)&cgen_var_563, 1 * 8);
+ stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_564;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_564, 1);
+ stream->write((uint64_t*)&cgen_var_564, 1 * 8);
+ stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+ stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkImageBlit(stream, (VkImageBlit*)(local_pRegions + i));
+ }
+ stream->write((VkFilter*)&local_filter, sizeof(VkFilter));
+}
+
+void VkEncoder::vkCmdCopyBufferToImage(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_srcBuffer;
+ VkImage local_dstImage;
+ VkImageLayout local_dstImageLayout;
+ uint32_t local_regionCount;
+ VkBufferImageCopy* local_pRegions;
+ local_commandBuffer = commandBuffer;
+ local_srcBuffer = srcBuffer;
+ local_dstImage = dstImage;
+ local_dstImageLayout = dstImageLayout;
+ local_regionCount = regionCount;
+ local_pRegions = nullptr;
+ if (pRegions)
+ {
+ local_pRegions = (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ deepcopy_VkBufferImageCopy(pool, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_565;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_565, 1);
+ countingStream->write((uint64_t*)&cgen_var_565, 1 * 8);
+ uint64_t cgen_var_566;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_566, 1);
+ countingStream->write((uint64_t*)&cgen_var_566, 1 * 8);
+ uint64_t cgen_var_567;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_567, 1);
+ countingStream->write((uint64_t*)&cgen_var_567, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+ countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkBufferImageCopy(countingStream, (VkBufferImageCopy*)(local_pRegions + i));
+ }
+ }
+ uint32_t packetSize_vkCmdCopyBufferToImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdCopyBufferToImage = OP_vkCmdCopyBufferToImage;
+ stream->write(&opcode_vkCmdCopyBufferToImage, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdCopyBufferToImage, sizeof(uint32_t));
+ uint64_t cgen_var_568;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_568, 1);
+ stream->write((uint64_t*)&cgen_var_568, 1 * 8);
+ uint64_t cgen_var_569;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_569, 1);
+ stream->write((uint64_t*)&cgen_var_569, 1 * 8);
+ uint64_t cgen_var_570;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_570, 1);
+ stream->write((uint64_t*)&cgen_var_570, 1 * 8);
+ stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+ stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i));
+ }
+}
+
+void VkEncoder::vkCmdCopyImageToBuffer(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkImage local_srcImage;
+ VkImageLayout local_srcImageLayout;
+ VkBuffer local_dstBuffer;
+ uint32_t local_regionCount;
+ VkBufferImageCopy* local_pRegions;
+ local_commandBuffer = commandBuffer;
+ local_srcImage = srcImage;
+ local_srcImageLayout = srcImageLayout;
+ local_dstBuffer = dstBuffer;
+ local_regionCount = regionCount;
+ local_pRegions = nullptr;
+ if (pRegions)
+ {
+ local_pRegions = (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ deepcopy_VkBufferImageCopy(pool, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_571;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_571, 1);
+ countingStream->write((uint64_t*)&cgen_var_571, 1 * 8);
+ uint64_t cgen_var_572;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_572, 1);
+ countingStream->write((uint64_t*)&cgen_var_572, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_573;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_573, 1);
+ countingStream->write((uint64_t*)&cgen_var_573, 1 * 8);
+ countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkBufferImageCopy(countingStream, (VkBufferImageCopy*)(local_pRegions + i));
+ }
+ }
+ uint32_t packetSize_vkCmdCopyImageToBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdCopyImageToBuffer = OP_vkCmdCopyImageToBuffer;
+ stream->write(&opcode_vkCmdCopyImageToBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdCopyImageToBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_574;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_574, 1);
+ stream->write((uint64_t*)&cgen_var_574, 1 * 8);
+ uint64_t cgen_var_575;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_575, 1);
+ stream->write((uint64_t*)&cgen_var_575, 1 * 8);
+ stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_576;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_576, 1);
+ stream->write((uint64_t*)&cgen_var_576, 1 * 8);
+ stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i));
+ }
+}
+
+void VkEncoder::vkCmdUpdateBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_dstBuffer;
+ VkDeviceSize local_dstOffset;
+ VkDeviceSize local_dataSize;
+ void* local_pData;
+ local_commandBuffer = commandBuffer;
+ local_dstBuffer = dstBuffer;
+ local_dstOffset = dstOffset;
+ local_dataSize = dataSize;
+ local_pData = nullptr;
+ if (pData)
+ {
+ local_pData = (void*)pool->dupArray(pData, ((dataSize)) * sizeof(const uint8_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_577;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_577, 1);
+ countingStream->write((uint64_t*)&cgen_var_577, 1 * 8);
+ uint64_t cgen_var_578;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_578, 1);
+ countingStream->write((uint64_t*)&cgen_var_578, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+ countingStream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
+ countingStream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
+ }
+ uint32_t packetSize_vkCmdUpdateBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdUpdateBuffer = OP_vkCmdUpdateBuffer;
+ stream->write(&opcode_vkCmdUpdateBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdUpdateBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_579;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_579, 1);
+ stream->write((uint64_t*)&cgen_var_579, 1 * 8);
+ uint64_t cgen_var_580;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_580, 1);
+ stream->write((uint64_t*)&cgen_var_580, 1 * 8);
+ stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+ stream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
+ stream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
+}
+
+void VkEncoder::vkCmdFillBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_dstBuffer;
+ VkDeviceSize local_dstOffset;
+ VkDeviceSize local_size;
+ uint32_t local_data;
+ local_commandBuffer = commandBuffer;
+ local_dstBuffer = dstBuffer;
+ local_dstOffset = dstOffset;
+ local_size = size;
+ local_data = data;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_581;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_581, 1);
+ countingStream->write((uint64_t*)&cgen_var_581, 1 * 8);
+ uint64_t cgen_var_582;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_582, 1);
+ countingStream->write((uint64_t*)&cgen_var_582, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+ countingStream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_data, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdFillBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdFillBuffer = OP_vkCmdFillBuffer;
+ stream->write(&opcode_vkCmdFillBuffer, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdFillBuffer, sizeof(uint32_t));
+ uint64_t cgen_var_583;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_583, 1);
+ stream->write((uint64_t*)&cgen_var_583, 1 * 8);
+ uint64_t cgen_var_584;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_584, 1);
+ stream->write((uint64_t*)&cgen_var_584, 1 * 8);
+ stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+ stream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_data, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdClearColorImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkImage local_image;
+ VkImageLayout local_imageLayout;
+ VkClearColorValue* local_pColor;
+ uint32_t local_rangeCount;
+ VkImageSubresourceRange* local_pRanges;
+ local_commandBuffer = commandBuffer;
+ local_image = image;
+ local_imageLayout = imageLayout;
+ local_pColor = nullptr;
+ if (pColor)
+ {
+ local_pColor = (VkClearColorValue*)pool->alloc(sizeof(const VkClearColorValue));
+ deepcopy_VkClearColorValue(pool, pColor, (VkClearColorValue*)(local_pColor));
+ }
+ local_rangeCount = rangeCount;
+ local_pRanges = nullptr;
+ if (pRanges)
+ {
+ local_pRanges = (VkImageSubresourceRange*)pool->alloc(((rangeCount)) * sizeof(const VkImageSubresourceRange));
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+ {
+ deepcopy_VkImageSubresourceRange(pool, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_585;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_585, 1);
+ countingStream->write((uint64_t*)&cgen_var_585, 1 * 8);
+ uint64_t cgen_var_586;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_586, 1);
+ countingStream->write((uint64_t*)&cgen_var_586, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
+ marshal_VkClearColorValue(countingStream, (VkClearColorValue*)(local_pColor));
+ countingStream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+ {
+ marshal_VkImageSubresourceRange(countingStream, (VkImageSubresourceRange*)(local_pRanges + i));
+ }
+ }
+ uint32_t packetSize_vkCmdClearColorImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdClearColorImage = OP_vkCmdClearColorImage;
+ stream->write(&opcode_vkCmdClearColorImage, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdClearColorImage, sizeof(uint32_t));
+ uint64_t cgen_var_587;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_587, 1);
+ stream->write((uint64_t*)&cgen_var_587, 1 * 8);
+ uint64_t cgen_var_588;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_588, 1);
+ stream->write((uint64_t*)&cgen_var_588, 1 * 8);
+ stream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
+ marshal_VkClearColorValue(stream, (VkClearColorValue*)(local_pColor));
+ stream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+ {
+ marshal_VkImageSubresourceRange(stream, (VkImageSubresourceRange*)(local_pRanges + i));
+ }
+}
+
+void VkEncoder::vkCmdClearDepthStencilImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkImage local_image;
+ VkImageLayout local_imageLayout;
+ VkClearDepthStencilValue* local_pDepthStencil;
+ uint32_t local_rangeCount;
+ VkImageSubresourceRange* local_pRanges;
+ local_commandBuffer = commandBuffer;
+ local_image = image;
+ local_imageLayout = imageLayout;
+ local_pDepthStencil = nullptr;
+ if (pDepthStencil)
+ {
+ local_pDepthStencil = (VkClearDepthStencilValue*)pool->alloc(sizeof(const VkClearDepthStencilValue));
+ deepcopy_VkClearDepthStencilValue(pool, pDepthStencil, (VkClearDepthStencilValue*)(local_pDepthStencil));
+ }
+ local_rangeCount = rangeCount;
+ local_pRanges = nullptr;
+ if (pRanges)
+ {
+ local_pRanges = (VkImageSubresourceRange*)pool->alloc(((rangeCount)) * sizeof(const VkImageSubresourceRange));
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+ {
+ deepcopy_VkImageSubresourceRange(pool, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_589;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_589, 1);
+ countingStream->write((uint64_t*)&cgen_var_589, 1 * 8);
+ uint64_t cgen_var_590;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_590, 1);
+ countingStream->write((uint64_t*)&cgen_var_590, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
+ marshal_VkClearDepthStencilValue(countingStream, (VkClearDepthStencilValue*)(local_pDepthStencil));
+ countingStream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+ {
+ marshal_VkImageSubresourceRange(countingStream, (VkImageSubresourceRange*)(local_pRanges + i));
+ }
+ }
+ uint32_t packetSize_vkCmdClearDepthStencilImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdClearDepthStencilImage = OP_vkCmdClearDepthStencilImage;
+ stream->write(&opcode_vkCmdClearDepthStencilImage, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdClearDepthStencilImage, sizeof(uint32_t));
+ uint64_t cgen_var_591;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_591, 1);
+ stream->write((uint64_t*)&cgen_var_591, 1 * 8);
+ uint64_t cgen_var_592;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_592, 1);
+ stream->write((uint64_t*)&cgen_var_592, 1 * 8);
+ stream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
+ marshal_VkClearDepthStencilValue(stream, (VkClearDepthStencilValue*)(local_pDepthStencil));
+ stream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
+ {
+ marshal_VkImageSubresourceRange(stream, (VkImageSubresourceRange*)(local_pRanges + i));
+ }
+}
+
+void VkEncoder::vkCmdClearAttachments(
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_attachmentCount;
+ VkClearAttachment* local_pAttachments;
+ uint32_t local_rectCount;
+ VkClearRect* local_pRects;
+ local_commandBuffer = commandBuffer;
+ local_attachmentCount = attachmentCount;
+ local_pAttachments = nullptr;
+ if (pAttachments)
+ {
+ local_pAttachments = (VkClearAttachment*)pool->alloc(((attachmentCount)) * sizeof(const VkClearAttachment));
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
+ {
+ deepcopy_VkClearAttachment(pool, pAttachments + i, (VkClearAttachment*)(local_pAttachments + i));
+ }
+ }
+ local_rectCount = rectCount;
+ local_pRects = nullptr;
+ if (pRects)
+ {
+ 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));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_593;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_593, 1);
+ countingStream->write((uint64_t*)&cgen_var_593, 1 * 8);
+ countingStream->write((uint32_t*)&local_attachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
+ {
+ marshal_VkClearAttachment(countingStream, (VkClearAttachment*)(local_pAttachments + i));
+ }
+ countingStream->write((uint32_t*)&local_rectCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
+ {
+ marshal_VkClearRect(countingStream, (VkClearRect*)(local_pRects + i));
+ }
+ }
+ uint32_t packetSize_vkCmdClearAttachments = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdClearAttachments = OP_vkCmdClearAttachments;
+ stream->write(&opcode_vkCmdClearAttachments, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdClearAttachments, sizeof(uint32_t));
+ uint64_t cgen_var_594;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_594, 1);
+ stream->write((uint64_t*)&cgen_var_594, 1 * 8);
+ stream->write((uint32_t*)&local_attachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
+ {
+ marshal_VkClearAttachment(stream, (VkClearAttachment*)(local_pAttachments + i));
+ }
+ stream->write((uint32_t*)&local_rectCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
+ {
+ marshal_VkClearRect(stream, (VkClearRect*)(local_pRects + i));
+ }
+}
+
+void VkEncoder::vkCmdResolveImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkImage local_srcImage;
+ VkImageLayout local_srcImageLayout;
+ VkImage local_dstImage;
+ VkImageLayout local_dstImageLayout;
+ uint32_t local_regionCount;
+ VkImageResolve* local_pRegions;
+ local_commandBuffer = commandBuffer;
+ local_srcImage = srcImage;
+ local_srcImageLayout = srcImageLayout;
+ local_dstImage = dstImage;
+ local_dstImageLayout = dstImageLayout;
+ local_regionCount = regionCount;
+ local_pRegions = nullptr;
+ if (pRegions)
+ {
+ local_pRegions = (VkImageResolve*)pool->alloc(((regionCount)) * sizeof(const VkImageResolve));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ deepcopy_VkImageResolve(pool, pRegions + i, (VkImageResolve*)(local_pRegions + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_595;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_595, 1);
+ countingStream->write((uint64_t*)&cgen_var_595, 1 * 8);
+ uint64_t cgen_var_596;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_596, 1);
+ countingStream->write((uint64_t*)&cgen_var_596, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_597;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_597, 1);
+ countingStream->write((uint64_t*)&cgen_var_597, 1 * 8);
+ countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+ countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkImageResolve(countingStream, (VkImageResolve*)(local_pRegions + i));
+ }
+ }
+ uint32_t packetSize_vkCmdResolveImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdResolveImage = OP_vkCmdResolveImage;
+ stream->write(&opcode_vkCmdResolveImage, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdResolveImage, sizeof(uint32_t));
+ uint64_t cgen_var_598;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_598, 1);
+ stream->write((uint64_t*)&cgen_var_598, 1 * 8);
+ uint64_t cgen_var_599;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_599, 1);
+ stream->write((uint64_t*)&cgen_var_599, 1 * 8);
+ stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_600;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_600, 1);
+ stream->write((uint64_t*)&cgen_var_600, 1 * 8);
+ stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
+ stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
+ {
+ marshal_VkImageResolve(stream, (VkImageResolve*)(local_pRegions + i));
+ }
+}
+
+void VkEncoder::vkCmdSetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkEvent local_event;
+ VkPipelineStageFlags local_stageMask;
+ local_commandBuffer = commandBuffer;
+ local_event = event;
+ local_stageMask = stageMask;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_601;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_601, 1);
+ countingStream->write((uint64_t*)&cgen_var_601, 1 * 8);
+ uint64_t cgen_var_602;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_602, 1);
+ countingStream->write((uint64_t*)&cgen_var_602, 1 * 8);
+ countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+ }
+ uint32_t packetSize_vkCmdSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetEvent = OP_vkCmdSetEvent;
+ stream->write(&opcode_vkCmdSetEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetEvent, sizeof(uint32_t));
+ uint64_t cgen_var_603;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_603, 1);
+ stream->write((uint64_t*)&cgen_var_603, 1 * 8);
+ uint64_t cgen_var_604;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_604, 1);
+ stream->write((uint64_t*)&cgen_var_604, 1 * 8);
+ stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+}
+
+void VkEncoder::vkCmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkEvent local_event;
+ VkPipelineStageFlags local_stageMask;
+ local_commandBuffer = commandBuffer;
+ local_event = event;
+ local_stageMask = stageMask;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_605;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_605, 1);
+ countingStream->write((uint64_t*)&cgen_var_605, 1 * 8);
+ uint64_t cgen_var_606;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_606, 1);
+ countingStream->write((uint64_t*)&cgen_var_606, 1 * 8);
+ countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+ }
+ uint32_t packetSize_vkCmdResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdResetEvent = OP_vkCmdResetEvent;
+ stream->write(&opcode_vkCmdResetEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdResetEvent, sizeof(uint32_t));
+ uint64_t cgen_var_607;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_607, 1);
+ stream->write((uint64_t*)&cgen_var_607, 1 * 8);
+ uint64_t cgen_var_608;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_608, 1);
+ stream->write((uint64_t*)&cgen_var_608, 1 * 8);
+ stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+}
+
+void VkEncoder::vkCmdWaitEvents(
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_eventCount;
+ VkEvent* local_pEvents;
+ VkPipelineStageFlags local_srcStageMask;
+ VkPipelineStageFlags local_dstStageMask;
+ uint32_t local_memoryBarrierCount;
+ VkMemoryBarrier* local_pMemoryBarriers;
+ uint32_t local_bufferMemoryBarrierCount;
+ VkBufferMemoryBarrier* local_pBufferMemoryBarriers;
+ uint32_t local_imageMemoryBarrierCount;
+ VkImageMemoryBarrier* local_pImageMemoryBarriers;
+ local_commandBuffer = commandBuffer;
+ local_eventCount = eventCount;
+ local_pEvents = nullptr;
+ if (pEvents)
+ {
+ local_pEvents = (VkEvent*)pool->dupArray(pEvents, ((eventCount)) * sizeof(const VkEvent));
+ }
+ local_srcStageMask = srcStageMask;
+ local_dstStageMask = dstStageMask;
+ local_memoryBarrierCount = memoryBarrierCount;
+ local_pMemoryBarriers = nullptr;
+ if (pMemoryBarriers)
+ {
+ local_pMemoryBarriers = (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+ {
+ deepcopy_VkMemoryBarrier(pool, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ }
+ }
+ local_bufferMemoryBarrierCount = bufferMemoryBarrierCount;
+ local_pBufferMemoryBarriers = nullptr;
+ if (pBufferMemoryBarriers)
+ {
+ local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+ {
+ deepcopy_VkBufferMemoryBarrier(pool, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ }
+ }
+ local_imageMemoryBarrierCount = imageMemoryBarrierCount;
+ local_pImageMemoryBarriers = nullptr;
+ if (pImageMemoryBarriers)
+ {
+ local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+ {
+ deepcopy_VkImageMemoryBarrier(pool, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_609;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_609, 1);
+ countingStream->write((uint64_t*)&cgen_var_609, 1 * 8);
+ countingStream->write((uint32_t*)&local_eventCount, sizeof(uint32_t));
+ if (((eventCount)))
+ {
+ uint64_t* cgen_var_610;
+ countingStream->alloc((void**)&cgen_var_610, ((eventCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_610, ((eventCount)));
+ countingStream->write((uint64_t*)cgen_var_610, ((eventCount)) * 8);
+ }
+ countingStream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
+ countingStream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
+ countingStream->write((uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+ {
+ marshal_VkMemoryBarrier(countingStream, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ }
+ countingStream->write((uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+ {
+ marshal_VkBufferMemoryBarrier(countingStream, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ }
+ countingStream->write((uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+ {
+ marshal_VkImageMemoryBarrier(countingStream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ }
+ }
+ uint32_t packetSize_vkCmdWaitEvents = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdWaitEvents = OP_vkCmdWaitEvents;
+ stream->write(&opcode_vkCmdWaitEvents, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdWaitEvents, sizeof(uint32_t));
+ uint64_t cgen_var_611;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_611, 1);
+ stream->write((uint64_t*)&cgen_var_611, 1 * 8);
+ stream->write((uint32_t*)&local_eventCount, sizeof(uint32_t));
+ if (((eventCount)))
+ {
+ uint64_t* cgen_var_612;
+ stream->alloc((void**)&cgen_var_612, ((eventCount)) * 8);
+ stream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_612, ((eventCount)));
+ stream->write((uint64_t*)cgen_var_612, ((eventCount)) * 8);
+ }
+ stream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
+ stream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
+ stream->write((uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+ {
+ marshal_VkMemoryBarrier(stream, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ }
+ stream->write((uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+ {
+ marshal_VkBufferMemoryBarrier(stream, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ }
+ stream->write((uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+ {
+ marshal_VkImageMemoryBarrier(stream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ }
+}
+
+void VkEncoder::vkCmdPipelineBarrier(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkPipelineStageFlags local_srcStageMask;
+ VkPipelineStageFlags local_dstStageMask;
+ VkDependencyFlags local_dependencyFlags;
+ uint32_t local_memoryBarrierCount;
+ VkMemoryBarrier* local_pMemoryBarriers;
+ uint32_t local_bufferMemoryBarrierCount;
+ VkBufferMemoryBarrier* local_pBufferMemoryBarriers;
+ uint32_t local_imageMemoryBarrierCount;
+ VkImageMemoryBarrier* local_pImageMemoryBarriers;
+ local_commandBuffer = commandBuffer;
+ local_srcStageMask = srcStageMask;
+ local_dstStageMask = dstStageMask;
+ local_dependencyFlags = dependencyFlags;
+ local_memoryBarrierCount = memoryBarrierCount;
+ local_pMemoryBarriers = nullptr;
+ if (pMemoryBarriers)
+ {
+ local_pMemoryBarriers = (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+ {
+ deepcopy_VkMemoryBarrier(pool, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ }
+ }
+ local_bufferMemoryBarrierCount = bufferMemoryBarrierCount;
+ local_pBufferMemoryBarriers = nullptr;
+ if (pBufferMemoryBarriers)
+ {
+ local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+ {
+ deepcopy_VkBufferMemoryBarrier(pool, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ }
+ }
+ local_imageMemoryBarrierCount = imageMemoryBarrierCount;
+ local_pImageMemoryBarriers = nullptr;
+ if (pImageMemoryBarriers)
+ {
+ local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+ {
+ deepcopy_VkImageMemoryBarrier(pool, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_613;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_613, 1);
+ countingStream->write((uint64_t*)&cgen_var_613, 1 * 8);
+ countingStream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
+ countingStream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
+ countingStream->write((VkDependencyFlags*)&local_dependencyFlags, sizeof(VkDependencyFlags));
+ countingStream->write((uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+ {
+ marshal_VkMemoryBarrier(countingStream, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ }
+ countingStream->write((uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+ {
+ marshal_VkBufferMemoryBarrier(countingStream, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ }
+ countingStream->write((uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+ {
+ marshal_VkImageMemoryBarrier(countingStream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ }
+ }
+ uint32_t packetSize_vkCmdPipelineBarrier = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdPipelineBarrier = OP_vkCmdPipelineBarrier;
+ stream->write(&opcode_vkCmdPipelineBarrier, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdPipelineBarrier, sizeof(uint32_t));
+ uint64_t cgen_var_614;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_614, 1);
+ stream->write((uint64_t*)&cgen_var_614, 1 * 8);
+ stream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
+ stream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
+ stream->write((VkDependencyFlags*)&local_dependencyFlags, sizeof(VkDependencyFlags));
+ stream->write((uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
+ {
+ marshal_VkMemoryBarrier(stream, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ }
+ stream->write((uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
+ {
+ marshal_VkBufferMemoryBarrier(stream, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ }
+ stream->write((uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
+ {
+ marshal_VkImageMemoryBarrier(stream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ }
+}
+
+void VkEncoder::vkCmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkQueryPool local_queryPool;
+ uint32_t local_query;
+ VkQueryControlFlags local_flags;
+ local_commandBuffer = commandBuffer;
+ local_queryPool = queryPool;
+ local_query = query;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_615;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_615, 1);
+ countingStream->write((uint64_t*)&cgen_var_615, 1 * 8);
+ uint64_t cgen_var_616;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_616, 1);
+ countingStream->write((uint64_t*)&cgen_var_616, 1 * 8);
+ countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
+ countingStream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
+ }
+ uint32_t packetSize_vkCmdBeginQuery = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBeginQuery = OP_vkCmdBeginQuery;
+ stream->write(&opcode_vkCmdBeginQuery, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBeginQuery, sizeof(uint32_t));
+ uint64_t cgen_var_617;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_617, 1);
+ stream->write((uint64_t*)&cgen_var_617, 1 * 8);
+ uint64_t cgen_var_618;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_618, 1);
+ stream->write((uint64_t*)&cgen_var_618, 1 * 8);
+ stream->write((uint32_t*)&local_query, sizeof(uint32_t));
+ stream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
+}
+
+void VkEncoder::vkCmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkQueryPool local_queryPool;
+ uint32_t local_query;
+ local_commandBuffer = commandBuffer;
+ local_queryPool = queryPool;
+ local_query = query;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_619;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_619, 1);
+ countingStream->write((uint64_t*)&cgen_var_619, 1 * 8);
+ uint64_t cgen_var_620;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_620, 1);
+ countingStream->write((uint64_t*)&cgen_var_620, 1 * 8);
+ countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdEndQuery = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdEndQuery = OP_vkCmdEndQuery;
+ stream->write(&opcode_vkCmdEndQuery, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdEndQuery, sizeof(uint32_t));
+ uint64_t cgen_var_621;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_621, 1);
+ stream->write((uint64_t*)&cgen_var_621, 1 * 8);
+ uint64_t cgen_var_622;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_622, 1);
+ stream->write((uint64_t*)&cgen_var_622, 1 * 8);
+ stream->write((uint32_t*)&local_query, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkQueryPool local_queryPool;
+ uint32_t local_firstQuery;
+ uint32_t local_queryCount;
+ local_commandBuffer = commandBuffer;
+ local_queryPool = queryPool;
+ local_firstQuery = firstQuery;
+ local_queryCount = queryCount;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_623;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_623, 1);
+ countingStream->write((uint64_t*)&cgen_var_623, 1 * 8);
+ uint64_t cgen_var_624;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_624, 1);
+ countingStream->write((uint64_t*)&cgen_var_624, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdResetQueryPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdResetQueryPool = OP_vkCmdResetQueryPool;
+ stream->write(&opcode_vkCmdResetQueryPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdResetQueryPool, sizeof(uint32_t));
+ uint64_t cgen_var_625;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_625, 1);
+ stream->write((uint64_t*)&cgen_var_625, 1 * 8);
+ uint64_t cgen_var_626;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_626, 1);
+ stream->write((uint64_t*)&cgen_var_626, 1 * 8);
+ stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkPipelineStageFlagBits local_pipelineStage;
+ VkQueryPool local_queryPool;
+ uint32_t local_query;
+ local_commandBuffer = commandBuffer;
+ local_pipelineStage = pipelineStage;
+ local_queryPool = queryPool;
+ local_query = query;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_627;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_627, 1);
+ countingStream->write((uint64_t*)&cgen_var_627, 1 * 8);
+ countingStream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+ uint64_t cgen_var_628;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_628, 1);
+ countingStream->write((uint64_t*)&cgen_var_628, 1 * 8);
+ countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdWriteTimestamp = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdWriteTimestamp = OP_vkCmdWriteTimestamp;
+ stream->write(&opcode_vkCmdWriteTimestamp, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdWriteTimestamp, sizeof(uint32_t));
+ uint64_t cgen_var_629;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_629, 1);
+ stream->write((uint64_t*)&cgen_var_629, 1 * 8);
+ stream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+ uint64_t cgen_var_630;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_630, 1);
+ stream->write((uint64_t*)&cgen_var_630, 1 * 8);
+ stream->write((uint32_t*)&local_query, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkQueryPool local_queryPool;
+ uint32_t local_firstQuery;
+ uint32_t local_queryCount;
+ VkBuffer local_dstBuffer;
+ VkDeviceSize local_dstOffset;
+ VkDeviceSize local_stride;
+ VkQueryResultFlags local_flags;
+ local_commandBuffer = commandBuffer;
+ local_queryPool = queryPool;
+ local_firstQuery = firstQuery;
+ local_queryCount = queryCount;
+ local_dstBuffer = dstBuffer;
+ local_dstOffset = dstOffset;
+ local_stride = stride;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_631;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_631, 1);
+ countingStream->write((uint64_t*)&cgen_var_631, 1 * 8);
+ uint64_t cgen_var_632;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_632, 1);
+ countingStream->write((uint64_t*)&cgen_var_632, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+ uint64_t cgen_var_633;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_633, 1);
+ countingStream->write((uint64_t*)&cgen_var_633, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+ countingStream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
+ countingStream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
+ }
+ uint32_t packetSize_vkCmdCopyQueryPoolResults = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdCopyQueryPoolResults = OP_vkCmdCopyQueryPoolResults;
+ stream->write(&opcode_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
+ uint64_t cgen_var_634;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_634, 1);
+ stream->write((uint64_t*)&cgen_var_634, 1 * 8);
+ uint64_t cgen_var_635;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_635, 1);
+ stream->write((uint64_t*)&cgen_var_635, 1 * 8);
+ stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
+ uint64_t cgen_var_636;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_636, 1);
+ stream->write((uint64_t*)&cgen_var_636, 1 * 8);
+ stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+ stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
+ stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
+}
+
+void VkEncoder::vkCmdPushConstants(
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkPipelineLayout local_layout;
+ VkShaderStageFlags local_stageFlags;
+ uint32_t local_offset;
+ uint32_t local_size;
+ void* local_pValues;
+ local_commandBuffer = commandBuffer;
+ local_layout = layout;
+ local_stageFlags = stageFlags;
+ local_offset = offset;
+ local_size = size;
+ local_pValues = nullptr;
+ if (pValues)
+ {
+ local_pValues = (void*)pool->dupArray(pValues, ((size)) * sizeof(const uint8_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_637;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_637, 1);
+ countingStream->write((uint64_t*)&cgen_var_637, 1 * 8);
+ uint64_t cgen_var_638;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_638, 1);
+ countingStream->write((uint64_t*)&cgen_var_638, 1 * 8);
+ countingStream->write((VkShaderStageFlags*)&local_stageFlags, sizeof(VkShaderStageFlags));
+ countingStream->write((uint32_t*)&local_offset, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_size, sizeof(uint32_t));
+ countingStream->write((void*)local_pValues, ((size)) * sizeof(uint8_t));
+ }
+ uint32_t packetSize_vkCmdPushConstants = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdPushConstants = OP_vkCmdPushConstants;
+ stream->write(&opcode_vkCmdPushConstants, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdPushConstants, sizeof(uint32_t));
+ uint64_t cgen_var_639;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_639, 1);
+ stream->write((uint64_t*)&cgen_var_639, 1 * 8);
+ uint64_t cgen_var_640;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_640, 1);
+ stream->write((uint64_t*)&cgen_var_640, 1 * 8);
+ stream->write((VkShaderStageFlags*)&local_stageFlags, sizeof(VkShaderStageFlags));
+ stream->write((uint32_t*)&local_offset, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_size, sizeof(uint32_t));
+ stream->write((void*)local_pValues, ((size)) * sizeof(uint8_t));
+}
+
+void VkEncoder::vkCmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkRenderPassBeginInfo* local_pRenderPassBegin;
+ VkSubpassContents local_contents;
+ local_commandBuffer = commandBuffer;
+ local_pRenderPassBegin = nullptr;
+ if (pRenderPassBegin)
+ {
+ local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
+ deepcopy_VkRenderPassBeginInfo(pool, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ }
+ local_contents = contents;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_641;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_641, 1);
+ countingStream->write((uint64_t*)&cgen_var_641, 1 * 8);
+ marshal_VkRenderPassBeginInfo(countingStream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ countingStream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
+ }
+ uint32_t packetSize_vkCmdBeginRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBeginRenderPass = OP_vkCmdBeginRenderPass;
+ stream->write(&opcode_vkCmdBeginRenderPass, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBeginRenderPass, sizeof(uint32_t));
+ uint64_t cgen_var_642;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_642, 1);
+ stream->write((uint64_t*)&cgen_var_642, 1 * 8);
+ marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
+}
+
+void VkEncoder::vkCmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkSubpassContents local_contents;
+ local_commandBuffer = commandBuffer;
+ local_contents = contents;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_643;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_643, 1);
+ countingStream->write((uint64_t*)&cgen_var_643, 1 * 8);
+ countingStream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
+ }
+ uint32_t packetSize_vkCmdNextSubpass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdNextSubpass = OP_vkCmdNextSubpass;
+ stream->write(&opcode_vkCmdNextSubpass, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdNextSubpass, sizeof(uint32_t));
+ uint64_t cgen_var_644;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_644, 1);
+ stream->write((uint64_t*)&cgen_var_644, 1 * 8);
+ stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
+}
+
+void VkEncoder::vkCmdEndRenderPass(
+ VkCommandBuffer commandBuffer)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ local_commandBuffer = commandBuffer;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_645;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_645, 1);
+ countingStream->write((uint64_t*)&cgen_var_645, 1 * 8);
+ }
+ uint32_t packetSize_vkCmdEndRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdEndRenderPass = OP_vkCmdEndRenderPass;
+ stream->write(&opcode_vkCmdEndRenderPass, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdEndRenderPass, sizeof(uint32_t));
+ uint64_t cgen_var_646;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_646, 1);
+ stream->write((uint64_t*)&cgen_var_646, 1 * 8);
+}
+
+void VkEncoder::vkCmdExecuteCommands(
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_commandBufferCount;
+ VkCommandBuffer* local_pCommandBuffers;
+ local_commandBuffer = commandBuffer;
+ local_commandBufferCount = commandBufferCount;
+ local_pCommandBuffers = nullptr;
+ if (pCommandBuffers)
+ {
+ local_pCommandBuffers = (VkCommandBuffer*)pool->dupArray(pCommandBuffers, ((commandBufferCount)) * sizeof(const VkCommandBuffer));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_647;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_647, 1);
+ countingStream->write((uint64_t*)&cgen_var_647, 1 * 8);
+ countingStream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
+ if (((commandBufferCount)))
+ {
+ uint64_t* cgen_var_648;
+ countingStream->alloc((void**)&cgen_var_648, ((commandBufferCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_648, ((commandBufferCount)));
+ countingStream->write((uint64_t*)cgen_var_648, ((commandBufferCount)) * 8);
+ }
+ }
+ uint32_t packetSize_vkCmdExecuteCommands = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdExecuteCommands = OP_vkCmdExecuteCommands;
+ stream->write(&opcode_vkCmdExecuteCommands, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdExecuteCommands, sizeof(uint32_t));
+ uint64_t cgen_var_649;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_649, 1);
+ stream->write((uint64_t*)&cgen_var_649, 1 * 8);
+ stream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
+ if (((commandBufferCount)))
+ {
+ uint64_t* cgen_var_650;
+ stream->alloc((void**)&cgen_var_650, ((commandBufferCount)) * 8);
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_650, ((commandBufferCount)));
+ stream->write((uint64_t*)cgen_var_650, ((commandBufferCount)) * 8);
+ }
+}
+
+#endif
+#ifdef VK_VERSION_1_1
+VkResult VkEncoder::vkEnumerateInstanceVersion(
+ uint32_t* pApiVersion)
+{
+ VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+ vkEnumerateInstanceVersion_VkResult_return = goldfish_vkEnumerateInstanceVersion(this, vkEnumerateInstanceVersion_VkResult_return, pApiVersion);
+ return vkEnumerateInstanceVersion_VkResult_return;
+}
+
+VkResult VkEncoder::vkBindBufferMemory2(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_bindInfoCount;
+ VkBindBufferMemoryInfo* local_pBindInfos;
+ local_device = device;
+ local_bindInfoCount = bindInfoCount;
+ local_pBindInfos = nullptr;
+ if (pBindInfos)
+ {
+ local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ deepcopy_VkBindBufferMemoryInfo(pool, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_651;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_651, 1);
+ countingStream->write((uint64_t*)&cgen_var_651, 1 * 8);
+ countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindBufferMemoryInfo(countingStream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ }
+ }
+ uint32_t packetSize_vkBindBufferMemory2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkBindBufferMemory2 = OP_vkBindBufferMemory2;
+ stream->write(&opcode_vkBindBufferMemory2, sizeof(uint32_t));
+ stream->write(&packetSize_vkBindBufferMemory2, sizeof(uint32_t));
+ uint64_t cgen_var_652;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_652, 1);
+ stream->write((uint64_t*)&cgen_var_652, 1 * 8);
+ stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ }
+ VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
+ stream->read(&vkBindBufferMemory2_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkBindBufferMemory2_VkResult_return;
+}
+
+VkResult VkEncoder::vkBindImageMemory2(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_bindInfoCount;
+ VkBindImageMemoryInfo* local_pBindInfos;
+ local_device = device;
+ local_bindInfoCount = bindInfoCount;
+ local_pBindInfos = nullptr;
+ if (pBindInfos)
+ {
+ local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ deepcopy_VkBindImageMemoryInfo(pool, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_653;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_653, 1);
+ countingStream->write((uint64_t*)&cgen_var_653, 1 * 8);
+ countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindImageMemoryInfo(countingStream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ }
+ }
+ uint32_t packetSize_vkBindImageMemory2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkBindImageMemory2 = OP_vkBindImageMemory2;
+ stream->write(&opcode_vkBindImageMemory2, sizeof(uint32_t));
+ stream->write(&packetSize_vkBindImageMemory2, sizeof(uint32_t));
+ uint64_t cgen_var_654;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_654, 1);
+ stream->write((uint64_t*)&cgen_var_654, 1 * 8);
+ stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ }
+ VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
+ stream->read(&vkBindImageMemory2_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkBindImageMemory2_VkResult_return;
+}
+
+void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_heapIndex;
+ uint32_t local_localDeviceIndex;
+ uint32_t local_remoteDeviceIndex;
+ local_device = device;
+ local_heapIndex = heapIndex;
+ local_localDeviceIndex = localDeviceIndex;
+ local_remoteDeviceIndex = remoteDeviceIndex;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_655;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_655, 1);
+ countingStream->write((uint64_t*)&cgen_var_655, 1 * 8);
+ countingStream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
+ countingStream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+ }
+ uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeatures = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDeviceGroupPeerMemoryFeatures = OP_vkGetDeviceGroupPeerMemoryFeatures;
+ stream->write(&opcode_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
+ uint64_t cgen_var_656;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_656, 1);
+ stream->write((uint64_t*)&cgen_var_656, 1 * 8);
+ stream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
+ stream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+ stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+}
+
+void VkEncoder::vkCmdSetDeviceMask(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_deviceMask;
+ local_commandBuffer = commandBuffer;
+ local_deviceMask = deviceMask;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_657;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_657, 1);
+ countingStream->write((uint64_t*)&cgen_var_657, 1 * 8);
+ countingStream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdSetDeviceMask = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetDeviceMask = OP_vkCmdSetDeviceMask;
+ stream->write(&opcode_vkCmdSetDeviceMask, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetDeviceMask, sizeof(uint32_t));
+ uint64_t cgen_var_658;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_658, 1);
+ stream->write((uint64_t*)&cgen_var_658, 1 * 8);
+ stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDispatchBase(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_baseGroupX;
+ uint32_t local_baseGroupY;
+ uint32_t local_baseGroupZ;
+ uint32_t local_groupCountX;
+ uint32_t local_groupCountY;
+ uint32_t local_groupCountZ;
+ local_commandBuffer = commandBuffer;
+ local_baseGroupX = baseGroupX;
+ local_baseGroupY = baseGroupY;
+ local_baseGroupZ = baseGroupZ;
+ local_groupCountX = groupCountX;
+ local_groupCountY = groupCountY;
+ local_groupCountZ = groupCountZ;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_659;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_659, 1);
+ countingStream->write((uint64_t*)&cgen_var_659, 1 * 8);
+ countingStream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDispatchBase = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDispatchBase = OP_vkCmdDispatchBase;
+ stream->write(&opcode_vkCmdDispatchBase, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDispatchBase, sizeof(uint32_t));
+ uint64_t cgen_var_660;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_660, 1);
+ stream->write((uint64_t*)&cgen_var_660, 1 * 8);
+ stream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+}
+
+VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ local_instance = instance;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_661;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_661, 1);
+ countingStream->write((uint64_t*)&cgen_var_661, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_662 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+ countingStream->putBe64(cgen_var_662);
+ if (pPhysicalDeviceGroupCount)
+ {
+ countingStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_663 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+ countingStream->putBe64(cgen_var_663);
+ if (pPhysicalDeviceGroupProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+ {
+ marshal_VkPhysicalDeviceGroupProperties(countingStream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkEnumeratePhysicalDeviceGroups = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkEnumeratePhysicalDeviceGroups = OP_vkEnumeratePhysicalDeviceGroups;
+ stream->write(&opcode_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
+ stream->write(&packetSize_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
+ uint64_t cgen_var_664;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_664, 1);
+ stream->write((uint64_t*)&cgen_var_664, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_665 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+ stream->putBe64(cgen_var_665);
+ if (pPhysicalDeviceGroupCount)
+ {
+ stream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_666 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+ stream->putBe64(cgen_var_666);
+ if (pPhysicalDeviceGroupProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+ {
+ marshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPhysicalDeviceGroupCount;
+ check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPhysicalDeviceGroupCount)
+ {
+ if (!(check_pPhysicalDeviceGroupCount))
+ {
+ fprintf(stderr, "fatal: pPhysicalDeviceGroupCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkPhysicalDeviceGroupProperties* check_pPhysicalDeviceGroupProperties;
+ check_pPhysicalDeviceGroupProperties = (VkPhysicalDeviceGroupProperties*)(uintptr_t)stream->getBe64();
+ if (pPhysicalDeviceGroupProperties)
+ {
+ if (!(check_pPhysicalDeviceGroupProperties))
+ {
+ fprintf(stderr, "fatal: pPhysicalDeviceGroupProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+ {
+ unmarshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ }
+ }
+ VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
+ stream->read(&vkEnumeratePhysicalDeviceGroups_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkEnumeratePhysicalDeviceGroups_VkResult_return;
+}
+
+void VkEncoder::vkGetImageMemoryRequirements2(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImageMemoryRequirementsInfo2* local_pInfo;
+ local_device = device;
+ local_pInfo = nullptr;
+ if (pInfo)
+ {
+ local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
+ deepcopy_VkImageMemoryRequirementsInfo2(pool, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_669;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_669, 1);
+ countingStream->write((uint64_t*)&cgen_var_669, 1 * 8);
+ marshal_VkImageMemoryRequirementsInfo2(countingStream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkGetImageMemoryRequirements2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetImageMemoryRequirements2 = OP_vkGetImageMemoryRequirements2;
+ stream->write(&opcode_vkGetImageMemoryRequirements2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetImageMemoryRequirements2, sizeof(uint32_t));
+ uint64_t cgen_var_670;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_670, 1);
+ stream->write((uint64_t*)&cgen_var_670, 1 * 8);
+ marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetBufferMemoryRequirements2(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBufferMemoryRequirementsInfo2* local_pInfo;
+ local_device = device;
+ local_pInfo = nullptr;
+ if (pInfo)
+ {
+ local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
+ deepcopy_VkBufferMemoryRequirementsInfo2(pool, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_671;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_671, 1);
+ countingStream->write((uint64_t*)&cgen_var_671, 1 * 8);
+ marshal_VkBufferMemoryRequirementsInfo2(countingStream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkGetBufferMemoryRequirements2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetBufferMemoryRequirements2 = OP_vkGetBufferMemoryRequirements2;
+ stream->write(&opcode_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
+ uint64_t cgen_var_672;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_672, 1);
+ stream->write((uint64_t*)&cgen_var_672, 1 * 8);
+ marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetImageSparseMemoryRequirements2(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImageSparseMemoryRequirementsInfo2* local_pInfo;
+ local_device = device;
+ local_pInfo = nullptr;
+ if (pInfo)
+ {
+ local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
+ deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_673;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_673, 1);
+ countingStream->write((uint64_t*)&cgen_var_673, 1 * 8);
+ marshal_VkImageSparseMemoryRequirementsInfo2(countingStream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_674 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ countingStream->putBe64(cgen_var_674);
+ if (pSparseMemoryRequirementCount)
+ {
+ countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_675 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ countingStream->putBe64(cgen_var_675);
+ if (pSparseMemoryRequirements)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ marshal_VkSparseImageMemoryRequirements2(countingStream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetImageSparseMemoryRequirements2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetImageSparseMemoryRequirements2 = OP_vkGetImageSparseMemoryRequirements2;
+ stream->write(&opcode_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
+ uint64_t cgen_var_676;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_676, 1);
+ stream->write((uint64_t*)&cgen_var_676, 1 * 8);
+ marshal_VkImageSparseMemoryRequirementsInfo2(stream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_677 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ stream->putBe64(cgen_var_677);
+ if (pSparseMemoryRequirementCount)
+ {
+ stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_678 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ stream->putBe64(cgen_var_678);
+ if (pSparseMemoryRequirements)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ marshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pSparseMemoryRequirementCount;
+ check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirementCount)
+ {
+ if (!(check_pSparseMemoryRequirementCount))
+ {
+ fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkSparseImageMemoryRequirements2* check_pSparseMemoryRequirements;
+ check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirements)
+ {
+ if (!(check_pSparseMemoryRequirements))
+ {
+ fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ unmarshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ }
+ }
+}
+
+void VkEncoder::vkGetPhysicalDeviceFeatures2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_681;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_681, 1);
+ countingStream->write((uint64_t*)&cgen_var_681, 1 * 8);
+ marshal_VkPhysicalDeviceFeatures2(countingStream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceFeatures2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceFeatures2 = OP_vkGetPhysicalDeviceFeatures2;
+ stream->write(&opcode_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
+ uint64_t cgen_var_682;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_682, 1);
+ stream->write((uint64_t*)&cgen_var_682, 1 * 8);
+ marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+ unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+}
+
+void VkEncoder::vkGetPhysicalDeviceProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties)
+{
+ goldfish_vkGetPhysicalDeviceProperties2(this, physicalDevice, pProperties);
+}
+
+void VkEncoder::vkGetPhysicalDeviceFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkFormat local_format;
+ local_physicalDevice = physicalDevice;
+ local_format = format;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_683;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_683, 1);
+ countingStream->write((uint64_t*)&cgen_var_683, 1 * 8);
+ countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ marshal_VkFormatProperties2(countingStream, (VkFormatProperties2*)(pFormatProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceFormatProperties2 = OP_vkGetPhysicalDeviceFormatProperties2;
+ stream->write(&opcode_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
+ uint64_t cgen_var_684;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_684, 1);
+ stream->write((uint64_t*)&cgen_var_684, 1 * 8);
+ stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
+ unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceImageFormatInfo2* local_pImageFormatInfo;
+ local_physicalDevice = physicalDevice;
+ local_pImageFormatInfo = nullptr;
+ if (pImageFormatInfo)
+ {
+ local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
+ deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_685;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_685, 1);
+ countingStream->write((uint64_t*)&cgen_var_685, 1 * 8);
+ marshal_VkPhysicalDeviceImageFormatInfo2(countingStream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ marshal_VkImageFormatProperties2(countingStream, (VkImageFormatProperties2*)(pImageFormatProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2 = OP_vkGetPhysicalDeviceImageFormatProperties2;
+ stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
+ uint64_t cgen_var_686;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_686, 1);
+ stream->write((uint64_t*)&cgen_var_686, 1 * 8);
+ marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
+ unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
+ VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceImageFormatProperties2_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_687;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_687, 1);
+ countingStream->write((uint64_t*)&cgen_var_687, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_688 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ countingStream->putBe64(cgen_var_688);
+ if (pQueueFamilyPropertyCount)
+ {
+ countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_689 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ countingStream->putBe64(cgen_var_689);
+ if (pQueueFamilyProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ marshal_VkQueueFamilyProperties2(countingStream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2 = OP_vkGetPhysicalDeviceQueueFamilyProperties2;
+ stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
+ uint64_t cgen_var_690;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_690, 1);
+ stream->write((uint64_t*)&cgen_var_690, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_691 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ stream->putBe64(cgen_var_691);
+ if (pQueueFamilyPropertyCount)
+ {
+ stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_692 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ stream->putBe64(cgen_var_692);
+ if (pQueueFamilyProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ marshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pQueueFamilyPropertyCount;
+ check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pQueueFamilyPropertyCount)
+ {
+ if (!(check_pQueueFamilyPropertyCount))
+ {
+ fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkQueueFamilyProperties2* check_pQueueFamilyProperties;
+ check_pQueueFamilyProperties = (VkQueueFamilyProperties2*)(uintptr_t)stream->getBe64();
+ if (pQueueFamilyProperties)
+ {
+ if (!(check_pQueueFamilyProperties))
+ {
+ fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ unmarshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ }
+ }
+}
+
+void VkEncoder::vkGetPhysicalDeviceMemoryProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_695;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_695, 1);
+ countingStream->write((uint64_t*)&cgen_var_695, 1 * 8);
+ marshal_VkPhysicalDeviceMemoryProperties2(countingStream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2 = OP_vkGetPhysicalDeviceMemoryProperties2;
+ stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
+ uint64_t cgen_var_696;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_696, 1);
+ stream->write((uint64_t*)&cgen_var_696, 1 * 8);
+ marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+ unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceSparseImageFormatInfo2* local_pFormatInfo;
+ local_physicalDevice = physicalDevice;
+ local_pFormatInfo = nullptr;
+ if (pFormatInfo)
+ {
+ local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
+ deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_697;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_697, 1);
+ countingStream->write((uint64_t*)&cgen_var_697, 1 * 8);
+ marshal_VkPhysicalDeviceSparseImageFormatInfo2(countingStream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_698 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_698);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_699 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_699);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkSparseImageFormatProperties2(countingStream, (VkSparseImageFormatProperties2*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2 = OP_vkGetPhysicalDeviceSparseImageFormatProperties2;
+ stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
+ uint64_t cgen_var_700;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_700, 1);
+ stream->write((uint64_t*)&cgen_var_700, 1 * 8);
+ marshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_701 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_701);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_702 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_702);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkSparseImageFormatProperties2* check_pProperties;
+ check_pProperties = (VkSparseImageFormatProperties2*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+ }
+ }
+}
+
+void VkEncoder::vkTrimCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkCommandPool local_commandPool;
+ VkCommandPoolTrimFlags local_flags;
+ local_device = device;
+ local_commandPool = commandPool;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_705;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_705, 1);
+ countingStream->write((uint64_t*)&cgen_var_705, 1 * 8);
+ uint64_t cgen_var_706;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_706, 1);
+ countingStream->write((uint64_t*)&cgen_var_706, 1 * 8);
+ countingStream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
+ }
+ uint32_t packetSize_vkTrimCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkTrimCommandPool = OP_vkTrimCommandPool;
+ stream->write(&opcode_vkTrimCommandPool, sizeof(uint32_t));
+ stream->write(&packetSize_vkTrimCommandPool, sizeof(uint32_t));
+ uint64_t cgen_var_707;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_707, 1);
+ stream->write((uint64_t*)&cgen_var_707, 1 * 8);
+ uint64_t cgen_var_708;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_708, 1);
+ stream->write((uint64_t*)&cgen_var_708, 1 * 8);
+ stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
+}
+
+void VkEncoder::vkGetDeviceQueue2(
+ VkDevice device,
+ const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDeviceQueueInfo2* local_pQueueInfo;
+ local_device = device;
+ local_pQueueInfo = nullptr;
+ if (pQueueInfo)
+ {
+ local_pQueueInfo = (VkDeviceQueueInfo2*)pool->alloc(sizeof(const VkDeviceQueueInfo2));
+ deepcopy_VkDeviceQueueInfo2(pool, pQueueInfo, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_709;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_709, 1);
+ countingStream->write((uint64_t*)&cgen_var_709, 1 * 8);
+ marshal_VkDeviceQueueInfo2(countingStream, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+ uint64_t cgen_var_710;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_710, 1);
+ countingStream->write((uint64_t*)&cgen_var_710, 8);
+ }
+ uint32_t packetSize_vkGetDeviceQueue2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDeviceQueue2 = OP_vkGetDeviceQueue2;
+ stream->write(&opcode_vkGetDeviceQueue2, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDeviceQueue2, sizeof(uint32_t));
+ uint64_t cgen_var_711;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_711, 1);
+ stream->write((uint64_t*)&cgen_var_711, 1 * 8);
+ marshal_VkDeviceQueueInfo2(stream, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_712;
+ stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_712, 1);
+ stream->write((uint64_t*)&cgen_var_712, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_713;
+ stream->read((uint64_t*)&cgen_var_713, 8);
+ stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_713, (VkQueue*)pQueue, 1);
+}
+
+VkResult VkEncoder::vkCreateSamplerYcbcrConversion(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSamplerYcbcrConversionCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
+ deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_714;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_714, 1);
+ countingStream->write((uint64_t*)&cgen_var_714, 1 * 8);
+ marshal_VkSamplerYcbcrConversionCreateInfo(countingStream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_715 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_715);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_716;
+ countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_716, 1);
+ countingStream->write((uint64_t*)&cgen_var_716, 8);
+ }
+ uint32_t packetSize_vkCreateSamplerYcbcrConversion = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateSamplerYcbcrConversion = OP_vkCreateSamplerYcbcrConversion;
+ stream->write(&opcode_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
+ uint64_t cgen_var_717;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_717, 1);
+ stream->write((uint64_t*)&cgen_var_717, 1 * 8);
+ marshal_VkSamplerYcbcrConversionCreateInfo(stream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_718 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_718);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_719;
+ stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_719, 1);
+ stream->write((uint64_t*)&cgen_var_719, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_720;
+ stream->read((uint64_t*)&cgen_var_720, 8);
+ stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_720, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateSamplerYcbcrConversion_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateSamplerYcbcrConversion_VkResult_return;
+}
+
+void VkEncoder::vkDestroySamplerYcbcrConversion(
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSamplerYcbcrConversion local_ycbcrConversion;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_ycbcrConversion = ycbcrConversion;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_721;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_721, 1);
+ countingStream->write((uint64_t*)&cgen_var_721, 1 * 8);
+ uint64_t cgen_var_722;
+ countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_722, 1);
+ countingStream->write((uint64_t*)&cgen_var_722, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_723 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_723);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroySamplerYcbcrConversion = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroySamplerYcbcrConversion = OP_vkDestroySamplerYcbcrConversion;
+ stream->write(&opcode_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
+ uint64_t cgen_var_724;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_724, 1);
+ stream->write((uint64_t*)&cgen_var_724, 1 * 8);
+ uint64_t cgen_var_725;
+ stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_725, 1);
+ stream->write((uint64_t*)&cgen_var_725, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_726 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_726);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
+}
+
+VkResult VkEncoder::vkCreateDescriptorUpdateTemplate(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorUpdateTemplateCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
+ deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_727;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_727, 1);
+ countingStream->write((uint64_t*)&cgen_var_727, 1 * 8);
+ marshal_VkDescriptorUpdateTemplateCreateInfo(countingStream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_728 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_728);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_729;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_729, 1);
+ countingStream->write((uint64_t*)&cgen_var_729, 8);
+ }
+ uint32_t packetSize_vkCreateDescriptorUpdateTemplate = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDescriptorUpdateTemplate = OP_vkCreateDescriptorUpdateTemplate;
+ stream->write(&opcode_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
+ uint64_t cgen_var_730;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_730, 1);
+ stream->write((uint64_t*)&cgen_var_730, 1 * 8);
+ marshal_VkDescriptorUpdateTemplateCreateInfo(stream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_731 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_731);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_732;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_732, 1);
+ stream->write((uint64_t*)&cgen_var_732, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_733;
+ stream->read((uint64_t*)&cgen_var_733, 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_733, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDescriptorUpdateTemplate_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDescriptorUpdateTemplate(
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_734;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_734, 1);
+ countingStream->write((uint64_t*)&cgen_var_734, 1 * 8);
+ uint64_t cgen_var_735;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_735, 1);
+ countingStream->write((uint64_t*)&cgen_var_735, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_736 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_736);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyDescriptorUpdateTemplate = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyDescriptorUpdateTemplate = OP_vkDestroyDescriptorUpdateTemplate;
+ stream->write(&opcode_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
+ uint64_t cgen_var_737;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_737, 1);
+ stream->write((uint64_t*)&cgen_var_737, 1 * 8);
+ uint64_t cgen_var_738;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_738, 1);
+ stream->write((uint64_t*)&cgen_var_738, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_739 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_739);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
+}
+
+void VkEncoder::vkUpdateDescriptorSetWithTemplate(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorSet local_descriptorSet;
+ VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+ void* local_pData;
+ local_device = device;
+ local_descriptorSet = descriptorSet;
+ local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+ local_pData = nullptr;
+ if (pData)
+ {
+ local_pData = (void*)pool->dupArray(pData, sizeof(const uint8_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_740;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_740, 1);
+ countingStream->write((uint64_t*)&cgen_var_740, 1 * 8);
+ uint64_t cgen_var_741;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_741, 1);
+ countingStream->write((uint64_t*)&cgen_var_741, 1 * 8);
+ uint64_t cgen_var_742;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_742, 1);
+ countingStream->write((uint64_t*)&cgen_var_742, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_743 = (uint64_t)(uintptr_t)local_pData;
+ countingStream->putBe64(cgen_var_743);
+ if (local_pData)
+ {
+ countingStream->write((void*)local_pData, sizeof(uint8_t));
+ }
+ }
+ uint32_t packetSize_vkUpdateDescriptorSetWithTemplate = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkUpdateDescriptorSetWithTemplate = OP_vkUpdateDescriptorSetWithTemplate;
+ stream->write(&opcode_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
+ stream->write(&packetSize_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
+ uint64_t cgen_var_744;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_744, 1);
+ stream->write((uint64_t*)&cgen_var_744, 1 * 8);
+ uint64_t cgen_var_745;
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_745, 1);
+ stream->write((uint64_t*)&cgen_var_745, 1 * 8);
+ uint64_t cgen_var_746;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_746, 1);
+ stream->write((uint64_t*)&cgen_var_746, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_747 = (uint64_t)(uintptr_t)local_pData;
+ stream->putBe64(cgen_var_747);
+ if (local_pData)
+ {
+ stream->write((void*)local_pData, sizeof(uint8_t));
+ }
+}
+
+void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceExternalBufferInfo* local_pExternalBufferInfo;
+ local_physicalDevice = physicalDevice;
+ local_pExternalBufferInfo = nullptr;
+ if (pExternalBufferInfo)
+ {
+ local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
+ deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_748;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_748, 1);
+ countingStream->write((uint64_t*)&cgen_var_748, 1 * 8);
+ marshal_VkPhysicalDeviceExternalBufferInfo(countingStream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ marshal_VkExternalBufferProperties(countingStream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceExternalBufferProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceExternalBufferProperties = OP_vkGetPhysicalDeviceExternalBufferProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
+ uint64_t cgen_var_749;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_749, 1);
+ stream->write((uint64_t*)&cgen_var_749, 1 * 8);
+ marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+ unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceExternalFenceInfo* local_pExternalFenceInfo;
+ local_physicalDevice = physicalDevice;
+ local_pExternalFenceInfo = nullptr;
+ if (pExternalFenceInfo)
+ {
+ local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
+ deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_750;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_750, 1);
+ countingStream->write((uint64_t*)&cgen_var_750, 1 * 8);
+ marshal_VkPhysicalDeviceExternalFenceInfo(countingStream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ marshal_VkExternalFenceProperties(countingStream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceExternalFenceProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceExternalFenceProperties = OP_vkGetPhysicalDeviceExternalFenceProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
+ uint64_t cgen_var_751;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_751, 1);
+ stream->write((uint64_t*)&cgen_var_751, 1 * 8);
+ marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+ unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceExternalSemaphoreInfo* local_pExternalSemaphoreInfo;
+ local_physicalDevice = physicalDevice;
+ local_pExternalSemaphoreInfo = nullptr;
+ if (pExternalSemaphoreInfo)
+ {
+ local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
+ deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_752;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_752, 1);
+ countingStream->write((uint64_t*)&cgen_var_752, 1 * 8);
+ marshal_VkPhysicalDeviceExternalSemaphoreInfo(countingStream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ marshal_VkExternalSemaphoreProperties(countingStream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceExternalSemaphoreProperties = OP_vkGetPhysicalDeviceExternalSemaphoreProperties;
+ stream->write(&opcode_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
+ uint64_t cgen_var_753;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_753, 1);
+ stream->write((uint64_t*)&cgen_var_753, 1 * 8);
+ marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+ unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+}
+
+void VkEncoder::vkGetDescriptorSetLayoutSupport(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorSetLayoutCreateInfo* local_pCreateInfo;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_754;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_754, 1);
+ countingStream->write((uint64_t*)&cgen_var_754, 1 * 8);
+ marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ marshal_VkDescriptorSetLayoutSupport(countingStream, (VkDescriptorSetLayoutSupport*)(pSupport));
+ }
+ uint32_t packetSize_vkGetDescriptorSetLayoutSupport = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDescriptorSetLayoutSupport = OP_vkGetDescriptorSetLayoutSupport;
+ stream->write(&opcode_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
+ uint64_t cgen_var_755;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_755, 1);
+ stream->write((uint64_t*)&cgen_var_755, 1 * 8);
+ marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
+ unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
+}
+
+#endif
+#ifdef VK_KHR_surface
+void VkEncoder::vkDestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkSurfaceKHR local_surface;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_surface = surface;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_756;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_756, 1);
+ countingStream->write((uint64_t*)&cgen_var_756, 1 * 8);
+ uint64_t cgen_var_757;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_757, 1);
+ countingStream->write((uint64_t*)&cgen_var_757, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_758 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_758);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroySurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroySurfaceKHR = OP_vkDestroySurfaceKHR;
+ stream->write(&opcode_vkDestroySurfaceKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroySurfaceKHR, sizeof(uint32_t));
+ uint64_t cgen_var_759;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_759, 1);
+ stream->write((uint64_t*)&cgen_var_759, 1 * 8);
+ uint64_t cgen_var_760;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_760, 1);
+ stream->write((uint64_t*)&cgen_var_760, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_761 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_761);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&surface);
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ uint32_t local_queueFamilyIndex;
+ VkSurfaceKHR local_surface;
+ local_physicalDevice = physicalDevice;
+ local_queueFamilyIndex = queueFamilyIndex;
+ local_surface = surface;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_762;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_762, 1);
+ countingStream->write((uint64_t*)&cgen_var_762, 1 * 8);
+ countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ uint64_t cgen_var_763;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_763, 1);
+ countingStream->write((uint64_t*)&cgen_var_763, 1 * 8);
+ countingStream->write((VkBool32*)pSupported, sizeof(VkBool32));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceSupportKHR = OP_vkGetPhysicalDeviceSurfaceSupportKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
+ uint64_t cgen_var_764;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_764, 1);
+ stream->write((uint64_t*)&cgen_var_764, 1 * 8);
+ stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ uint64_t cgen_var_765;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_765, 1);
+ stream->write((uint64_t*)&cgen_var_765, 1 * 8);
+ stream->write((VkBool32*)pSupported, sizeof(VkBool32));
+ stream->read((VkBool32*)pSupported, sizeof(VkBool32));
+ VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkSurfaceKHR local_surface;
+ local_physicalDevice = physicalDevice;
+ local_surface = surface;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_766;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_766, 1);
+ countingStream->write((uint64_t*)&cgen_var_766, 1 * 8);
+ uint64_t cgen_var_767;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_767, 1);
+ countingStream->write((uint64_t*)&cgen_var_767, 1 * 8);
+ marshal_VkSurfaceCapabilitiesKHR(countingStream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_768;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_768, 1);
+ stream->write((uint64_t*)&cgen_var_768, 1 * 8);
+ uint64_t cgen_var_769;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_769, 1);
+ stream->write((uint64_t*)&cgen_var_769, 1 * 8);
+ marshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
+ unmarshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
+ VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkSurfaceKHR local_surface;
+ local_physicalDevice = physicalDevice;
+ local_surface = surface;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_770;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_770, 1);
+ countingStream->write((uint64_t*)&cgen_var_770, 1 * 8);
+ uint64_t cgen_var_771;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_771, 1);
+ countingStream->write((uint64_t*)&cgen_var_771, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_772 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+ countingStream->putBe64(cgen_var_772);
+ if (pSurfaceFormatCount)
+ {
+ countingStream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_773 = (uint64_t)(uintptr_t)pSurfaceFormats;
+ countingStream->putBe64(cgen_var_773);
+ if (pSurfaceFormats)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+ {
+ marshal_VkSurfaceFormatKHR(countingStream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceFormatsKHR = OP_vkGetPhysicalDeviceSurfaceFormatsKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
+ uint64_t cgen_var_774;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_774, 1);
+ stream->write((uint64_t*)&cgen_var_774, 1 * 8);
+ uint64_t cgen_var_775;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_775, 1);
+ stream->write((uint64_t*)&cgen_var_775, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_776 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+ stream->putBe64(cgen_var_776);
+ if (pSurfaceFormatCount)
+ {
+ stream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_777 = (uint64_t)(uintptr_t)pSurfaceFormats;
+ stream->putBe64(cgen_var_777);
+ if (pSurfaceFormats)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+ {
+ marshal_VkSurfaceFormatKHR(stream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pSurfaceFormatCount;
+ check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pSurfaceFormatCount)
+ {
+ if (!(check_pSurfaceFormatCount))
+ {
+ fprintf(stderr, "fatal: pSurfaceFormatCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkSurfaceFormatKHR* check_pSurfaceFormats;
+ check_pSurfaceFormats = (VkSurfaceFormatKHR*)(uintptr_t)stream->getBe64();
+ if (pSurfaceFormats)
+ {
+ if (!(check_pSurfaceFormats))
+ {
+ fprintf(stderr, "fatal: pSurfaceFormats inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+ {
+ unmarshal_VkSurfaceFormatKHR(stream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+ }
+ }
+ VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkSurfaceKHR local_surface;
+ local_physicalDevice = physicalDevice;
+ local_surface = surface;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_780;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_780, 1);
+ countingStream->write((uint64_t*)&cgen_var_780, 1 * 8);
+ uint64_t cgen_var_781;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_781, 1);
+ countingStream->write((uint64_t*)&cgen_var_781, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_782 = (uint64_t)(uintptr_t)pPresentModeCount;
+ countingStream->putBe64(cgen_var_782);
+ if (pPresentModeCount)
+ {
+ countingStream->write((uint32_t*)pPresentModeCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_783 = (uint64_t)(uintptr_t)pPresentModes;
+ countingStream->putBe64(cgen_var_783);
+ if (pPresentModes)
+ {
+ countingStream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSurfacePresentModesKHR = OP_vkGetPhysicalDeviceSurfacePresentModesKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_784;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_784, 1);
+ stream->write((uint64_t*)&cgen_var_784, 1 * 8);
+ uint64_t cgen_var_785;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_785, 1);
+ stream->write((uint64_t*)&cgen_var_785, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_786 = (uint64_t)(uintptr_t)pPresentModeCount;
+ stream->putBe64(cgen_var_786);
+ if (pPresentModeCount)
+ {
+ stream->write((uint32_t*)pPresentModeCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_787 = (uint64_t)(uintptr_t)pPresentModes;
+ stream->putBe64(cgen_var_787);
+ if (pPresentModes)
+ {
+ stream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPresentModeCount;
+ check_pPresentModeCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPresentModeCount)
+ {
+ if (!(check_pPresentModeCount))
+ {
+ fprintf(stderr, "fatal: pPresentModeCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPresentModeCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkPresentModeKHR* check_pPresentModes;
+ check_pPresentModes = (VkPresentModeKHR*)(uintptr_t)stream->getBe64();
+ if (pPresentModes)
+ {
+ if (!(check_pPresentModes))
+ {
+ fprintf(stderr, "fatal: pPresentModes inconsistent between guest and host\n");
+ }
+ stream->read((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+ }
+ VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_swapchain
+VkResult VkEncoder::vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSwapchainCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkSwapchainCreateInfoKHR*)pool->alloc(sizeof(const VkSwapchainCreateInfoKHR));
+ deepcopy_VkSwapchainCreateInfoKHR(pool, pCreateInfo, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_790;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_790, 1);
+ countingStream->write((uint64_t*)&cgen_var_790, 1 * 8);
+ marshal_VkSwapchainCreateInfoKHR(countingStream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_791 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_791);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_792;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_792, 1);
+ countingStream->write((uint64_t*)&cgen_var_792, 8);
+ }
+ uint32_t packetSize_vkCreateSwapchainKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateSwapchainKHR = OP_vkCreateSwapchainKHR;
+ stream->write(&opcode_vkCreateSwapchainKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateSwapchainKHR, sizeof(uint32_t));
+ uint64_t cgen_var_793;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_793, 1);
+ stream->write((uint64_t*)&cgen_var_793, 1 * 8);
+ marshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_794 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_794);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_795;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_795, 1);
+ stream->write((uint64_t*)&cgen_var_795, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_796;
+ stream->read((uint64_t*)&cgen_var_796, 8);
+ stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_796, (VkSwapchainKHR*)pSwapchain, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateSwapchainKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateSwapchainKHR_VkResult_return;
+}
+
+void VkEncoder::vkDestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSwapchainKHR local_swapchain;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_swapchain = swapchain;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_797;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_797, 1);
+ countingStream->write((uint64_t*)&cgen_var_797, 1 * 8);
+ uint64_t cgen_var_798;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_798, 1);
+ countingStream->write((uint64_t*)&cgen_var_798, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_799 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_799);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroySwapchainKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroySwapchainKHR = OP_vkDestroySwapchainKHR;
+ stream->write(&opcode_vkDestroySwapchainKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroySwapchainKHR, sizeof(uint32_t));
+ uint64_t cgen_var_800;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_800, 1);
+ stream->write((uint64_t*)&cgen_var_800, 1 * 8);
+ uint64_t cgen_var_801;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_801, 1);
+ stream->write((uint64_t*)&cgen_var_801, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_802 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_802);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&swapchain);
+}
+
+VkResult VkEncoder::vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSwapchainKHR local_swapchain;
+ local_device = device;
+ local_swapchain = swapchain;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_803;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_803, 1);
+ countingStream->write((uint64_t*)&cgen_var_803, 1 * 8);
+ uint64_t cgen_var_804;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_804, 1);
+ countingStream->write((uint64_t*)&cgen_var_804, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_805 = (uint64_t)(uintptr_t)pSwapchainImageCount;
+ countingStream->putBe64(cgen_var_805);
+ if (pSwapchainImageCount)
+ {
+ countingStream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_806 = (uint64_t)(uintptr_t)pSwapchainImages;
+ countingStream->putBe64(cgen_var_806);
+ if (pSwapchainImages)
+ {
+ if ((*(pSwapchainImageCount)))
+ {
+ uint64_t* cgen_var_807;
+ countingStream->alloc((void**)&cgen_var_807, (*(pSwapchainImageCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_807, (*(pSwapchainImageCount)));
+ countingStream->write((uint64_t*)cgen_var_807, (*(pSwapchainImageCount)) * 8);
+ }
+ }
+ }
+ uint32_t packetSize_vkGetSwapchainImagesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetSwapchainImagesKHR = OP_vkGetSwapchainImagesKHR;
+ stream->write(&opcode_vkGetSwapchainImagesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetSwapchainImagesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_808;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_808, 1);
+ stream->write((uint64_t*)&cgen_var_808, 1 * 8);
+ uint64_t cgen_var_809;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_809, 1);
+ stream->write((uint64_t*)&cgen_var_809, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_810 = (uint64_t)(uintptr_t)pSwapchainImageCount;
+ stream->putBe64(cgen_var_810);
+ if (pSwapchainImageCount)
+ {
+ stream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ // WARNING PTR CHECK
+ uint64_t cgen_var_811 = (uint64_t)(uintptr_t)pSwapchainImages;
+ stream->putBe64(cgen_var_811);
+ if (pSwapchainImages)
+ {
+ if ((*(pSwapchainImageCount)))
+ {
+ uint64_t* cgen_var_812;
+ stream->alloc((void**)&cgen_var_812, (*(pSwapchainImageCount)) * 8);
+ stream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_812, (*(pSwapchainImageCount)));
+ stream->write((uint64_t*)cgen_var_812, (*(pSwapchainImageCount)) * 8);
+ }
+ }
+ stream->setHandleMapping(resources->unwrapMapping());
+ // WARNING PTR CHECK
+ uint32_t* check_pSwapchainImageCount;
+ check_pSwapchainImageCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pSwapchainImageCount)
+ {
+ if (!(check_pSwapchainImageCount))
+ {
+ fprintf(stderr, "fatal: pSwapchainImageCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkImage* check_pSwapchainImages;
+ check_pSwapchainImages = (VkImage*)(uintptr_t)stream->getBe64();
+ if (pSwapchainImages)
+ {
+ if (!(check_pSwapchainImages))
+ {
+ fprintf(stderr, "fatal: pSwapchainImages inconsistent between guest and host\n");
+ }
+ if ((*(pSwapchainImageCount)))
+ {
+ uint64_t* cgen_var_815;
+ stream->alloc((void**)&cgen_var_815, (*(pSwapchainImageCount)) * 8);
+ stream->read((uint64_t*)cgen_var_815, (*(pSwapchainImageCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_815, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
+ }
+ }
+ VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetSwapchainImagesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetSwapchainImagesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkAcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSwapchainKHR local_swapchain;
+ uint64_t local_timeout;
+ VkSemaphore local_semaphore;
+ VkFence local_fence;
+ local_device = device;
+ local_swapchain = swapchain;
+ local_timeout = timeout;
+ local_semaphore = semaphore;
+ local_fence = fence;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_816;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_816, 1);
+ countingStream->write((uint64_t*)&cgen_var_816, 1 * 8);
+ uint64_t cgen_var_817;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_817, 1);
+ countingStream->write((uint64_t*)&cgen_var_817, 1 * 8);
+ countingStream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
+ uint64_t cgen_var_818;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_818, 1);
+ countingStream->write((uint64_t*)&cgen_var_818, 1 * 8);
+ uint64_t cgen_var_819;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_819, 1);
+ countingStream->write((uint64_t*)&cgen_var_819, 1 * 8);
+ countingStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkAcquireNextImageKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkAcquireNextImageKHR = OP_vkAcquireNextImageKHR;
+ stream->write(&opcode_vkAcquireNextImageKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkAcquireNextImageKHR, sizeof(uint32_t));
+ uint64_t cgen_var_820;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_820, 1);
+ stream->write((uint64_t*)&cgen_var_820, 1 * 8);
+ uint64_t cgen_var_821;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_821, 1);
+ stream->write((uint64_t*)&cgen_var_821, 1 * 8);
+ stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
+ uint64_t cgen_var_822;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_822, 1);
+ stream->write((uint64_t*)&cgen_var_822, 1 * 8);
+ uint64_t cgen_var_823;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_823, 1);
+ stream->write((uint64_t*)&cgen_var_823, 1 * 8);
+ stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
+ stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
+ VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkAcquireNextImageKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkAcquireNextImageKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkQueuePresentKHR(
+ VkQueue queue,
+ const VkPresentInfoKHR* pPresentInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ VkPresentInfoKHR* local_pPresentInfo;
+ local_queue = queue;
+ local_pPresentInfo = nullptr;
+ if (pPresentInfo)
+ {
+ local_pPresentInfo = (VkPresentInfoKHR*)pool->alloc(sizeof(const VkPresentInfoKHR));
+ deepcopy_VkPresentInfoKHR(pool, pPresentInfo, (VkPresentInfoKHR*)(local_pPresentInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_824;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_824, 1);
+ countingStream->write((uint64_t*)&cgen_var_824, 1 * 8);
+ marshal_VkPresentInfoKHR(countingStream, (VkPresentInfoKHR*)(local_pPresentInfo));
+ }
+ uint32_t packetSize_vkQueuePresentKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueuePresentKHR = OP_vkQueuePresentKHR;
+ stream->write(&opcode_vkQueuePresentKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueuePresentKHR, sizeof(uint32_t));
+ uint64_t cgen_var_825;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_825, 1);
+ stream->write((uint64_t*)&cgen_var_825, 1 * 8);
+ marshal_VkPresentInfoKHR(stream, (VkPresentInfoKHR*)(local_pPresentInfo));
+ VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkQueuePresentKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkQueuePresentKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR(
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ local_device = device;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_826;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_826, 1);
+ countingStream->write((uint64_t*)&cgen_var_826, 1 * 8);
+ marshal_VkDeviceGroupPresentCapabilitiesKHR(countingStream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
+ }
+ uint32_t packetSize_vkGetDeviceGroupPresentCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDeviceGroupPresentCapabilitiesKHR = OP_vkGetDeviceGroupPresentCapabilitiesKHR;
+ stream->write(&opcode_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_827;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_827, 1);
+ stream->write((uint64_t*)&cgen_var_827, 1 * 8);
+ marshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
+ unmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
+ VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHR* pModes)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSurfaceKHR local_surface;
+ local_device = device;
+ local_surface = surface;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_828;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_828, 1);
+ countingStream->write((uint64_t*)&cgen_var_828, 1 * 8);
+ uint64_t cgen_var_829;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_829, 1);
+ countingStream->write((uint64_t*)&cgen_var_829, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_830 = (uint64_t)(uintptr_t)pModes;
+ countingStream->putBe64(cgen_var_830);
+ if (pModes)
+ {
+ countingStream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ }
+ }
+ uint32_t packetSize_vkGetDeviceGroupSurfacePresentModesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDeviceGroupSurfacePresentModesKHR = OP_vkGetDeviceGroupSurfacePresentModesKHR;
+ stream->write(&opcode_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_831;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_831, 1);
+ stream->write((uint64_t*)&cgen_var_831, 1 * 8);
+ uint64_t cgen_var_832;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_832, 1);
+ stream->write((uint64_t*)&cgen_var_832, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_833 = (uint64_t)(uintptr_t)pModes;
+ stream->putBe64(cgen_var_833);
+ if (pModes)
+ {
+ stream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ }
+ // WARNING PTR CHECK
+ VkDeviceGroupPresentModeFlagsKHR* check_pModes;
+ check_pModes = (VkDeviceGroupPresentModeFlagsKHR*)(uintptr_t)stream->getBe64();
+ if (pModes)
+ {
+ if (!(check_pModes))
+ {
+ fprintf(stderr, "fatal: pModes inconsistent between guest and host\n");
+ }
+ stream->read((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ }
+ VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkSurfaceKHR local_surface;
+ local_physicalDevice = physicalDevice;
+ local_surface = surface;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_835;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_835, 1);
+ countingStream->write((uint64_t*)&cgen_var_835, 1 * 8);
+ uint64_t cgen_var_836;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_836, 1);
+ countingStream->write((uint64_t*)&cgen_var_836, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_837 = (uint64_t)(uintptr_t)pRectCount;
+ countingStream->putBe64(cgen_var_837);
+ if (pRectCount)
+ {
+ countingStream->write((uint32_t*)pRectCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_838 = (uint64_t)(uintptr_t)pRects;
+ countingStream->putBe64(cgen_var_838);
+ if (pRects)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
+ {
+ marshal_VkRect2D(countingStream, (VkRect2D*)(pRects + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDevicePresentRectanglesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDevicePresentRectanglesKHR = OP_vkGetPhysicalDevicePresentRectanglesKHR;
+ stream->write(&opcode_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_839;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_839, 1);
+ stream->write((uint64_t*)&cgen_var_839, 1 * 8);
+ uint64_t cgen_var_840;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_840, 1);
+ stream->write((uint64_t*)&cgen_var_840, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_841 = (uint64_t)(uintptr_t)pRectCount;
+ stream->putBe64(cgen_var_841);
+ if (pRectCount)
+ {
+ stream->write((uint32_t*)pRectCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_842 = (uint64_t)(uintptr_t)pRects;
+ stream->putBe64(cgen_var_842);
+ if (pRects)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
+ {
+ marshal_VkRect2D(stream, (VkRect2D*)(pRects + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pRectCount;
+ check_pRectCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pRectCount)
+ {
+ if (!(check_pRectCount))
+ {
+ fprintf(stderr, "fatal: pRectCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pRectCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkRect2D* check_pRects;
+ check_pRects = (VkRect2D*)(uintptr_t)stream->getBe64();
+ if (pRects)
+ {
+ if (!(check_pRects))
+ {
+ fprintf(stderr, "fatal: pRects inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
+ {
+ unmarshal_VkRect2D(stream, (VkRect2D*)(pRects + i));
+ }
+ }
+ VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkAcquireNextImage2KHR(
+ VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkAcquireNextImageInfoKHR* local_pAcquireInfo;
+ local_device = device;
+ local_pAcquireInfo = nullptr;
+ if (pAcquireInfo)
+ {
+ local_pAcquireInfo = (VkAcquireNextImageInfoKHR*)pool->alloc(sizeof(const VkAcquireNextImageInfoKHR));
+ deepcopy_VkAcquireNextImageInfoKHR(pool, pAcquireInfo, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_845;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_845, 1);
+ countingStream->write((uint64_t*)&cgen_var_845, 1 * 8);
+ marshal_VkAcquireNextImageInfoKHR(countingStream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+ countingStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkAcquireNextImage2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkAcquireNextImage2KHR = OP_vkAcquireNextImage2KHR;
+ stream->write(&opcode_vkAcquireNextImage2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkAcquireNextImage2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_846;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_846, 1);
+ stream->write((uint64_t*)&cgen_var_846, 1 * 8);
+ marshal_VkAcquireNextImageInfoKHR(stream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+ stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
+ stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
+ VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkAcquireNextImage2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkAcquireNextImage2KHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_display
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_847;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_847, 1);
+ countingStream->write((uint64_t*)&cgen_var_847, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_848 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_848);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_849 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_849);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayPropertiesKHR(countingStream, (VkDisplayPropertiesKHR*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceDisplayPropertiesKHR = OP_vkGetPhysicalDeviceDisplayPropertiesKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_850;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_850, 1);
+ stream->write((uint64_t*)&cgen_var_850, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_851 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_851);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_852 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_852);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayPropertiesKHR(stream, (VkDisplayPropertiesKHR*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkDisplayPropertiesKHR* check_pProperties;
+ check_pProperties = (VkDisplayPropertiesKHR*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkDisplayPropertiesKHR(stream, (VkDisplayPropertiesKHR*)(pProperties + i));
+ }
+ }
+ VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_855;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_855, 1);
+ countingStream->write((uint64_t*)&cgen_var_855, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_856 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_856);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_857 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_857);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayPlanePropertiesKHR(countingStream, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_858;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_858, 1);
+ stream->write((uint64_t*)&cgen_var_858, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_859 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_859);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_860 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_860);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayPlanePropertiesKHR(stream, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkDisplayPlanePropertiesKHR* check_pProperties;
+ check_pProperties = (VkDisplayPlanePropertiesKHR*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkDisplayPlanePropertiesKHR(stream, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+ }
+ }
+ VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ uint32_t local_planeIndex;
+ local_physicalDevice = physicalDevice;
+ local_planeIndex = planeIndex;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_863;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_863, 1);
+ countingStream->write((uint64_t*)&cgen_var_863, 1 * 8);
+ countingStream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_864 = (uint64_t)(uintptr_t)pDisplayCount;
+ countingStream->putBe64(cgen_var_864);
+ if (pDisplayCount)
+ {
+ countingStream->write((uint32_t*)pDisplayCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_865 = (uint64_t)(uintptr_t)pDisplays;
+ countingStream->putBe64(cgen_var_865);
+ if (pDisplays)
+ {
+ if ((*(pDisplayCount)))
+ {
+ uint64_t* cgen_var_866;
+ countingStream->alloc((void**)&cgen_var_866, (*(pDisplayCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_866, (*(pDisplayCount)));
+ countingStream->write((uint64_t*)cgen_var_866, (*(pDisplayCount)) * 8);
+ }
+ }
+ }
+ uint32_t packetSize_vkGetDisplayPlaneSupportedDisplaysKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDisplayPlaneSupportedDisplaysKHR = OP_vkGetDisplayPlaneSupportedDisplaysKHR;
+ stream->write(&opcode_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
+ uint64_t cgen_var_867;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_867, 1);
+ stream->write((uint64_t*)&cgen_var_867, 1 * 8);
+ stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_868 = (uint64_t)(uintptr_t)pDisplayCount;
+ stream->putBe64(cgen_var_868);
+ if (pDisplayCount)
+ {
+ stream->write((uint32_t*)pDisplayCount, sizeof(uint32_t));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ // WARNING PTR CHECK
+ uint64_t cgen_var_869 = (uint64_t)(uintptr_t)pDisplays;
+ stream->putBe64(cgen_var_869);
+ if (pDisplays)
+ {
+ if ((*(pDisplayCount)))
+ {
+ uint64_t* cgen_var_870;
+ stream->alloc((void**)&cgen_var_870, (*(pDisplayCount)) * 8);
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_870, (*(pDisplayCount)));
+ stream->write((uint64_t*)cgen_var_870, (*(pDisplayCount)) * 8);
+ }
+ }
+ stream->setHandleMapping(resources->unwrapMapping());
+ // WARNING PTR CHECK
+ uint32_t* check_pDisplayCount;
+ check_pDisplayCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pDisplayCount)
+ {
+ if (!(check_pDisplayCount))
+ {
+ fprintf(stderr, "fatal: pDisplayCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pDisplayCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkDisplayKHR* check_pDisplays;
+ check_pDisplays = (VkDisplayKHR*)(uintptr_t)stream->getBe64();
+ if (pDisplays)
+ {
+ if (!(check_pDisplays))
+ {
+ fprintf(stderr, "fatal: pDisplays inconsistent between guest and host\n");
+ }
+ if ((*(pDisplayCount)))
+ {
+ uint64_t* cgen_var_873;
+ stream->alloc((void**)&cgen_var_873, (*(pDisplayCount)) * 8);
+ stream->read((uint64_t*)cgen_var_873, (*(pDisplayCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_873, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
+ }
+ }
+ VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkDisplayKHR local_display;
+ local_physicalDevice = physicalDevice;
+ local_display = display;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_874;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_874, 1);
+ countingStream->write((uint64_t*)&cgen_var_874, 1 * 8);
+ uint64_t cgen_var_875;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_875, 1);
+ countingStream->write((uint64_t*)&cgen_var_875, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_876 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_876);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_877 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_877);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayModePropertiesKHR(countingStream, (VkDisplayModePropertiesKHR*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetDisplayModePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDisplayModePropertiesKHR = OP_vkGetDisplayModePropertiesKHR;
+ stream->write(&opcode_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_878;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_878, 1);
+ stream->write((uint64_t*)&cgen_var_878, 1 * 8);
+ uint64_t cgen_var_879;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_879, 1);
+ stream->write((uint64_t*)&cgen_var_879, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_880 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_880);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_881 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_881);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayModePropertiesKHR(stream, (VkDisplayModePropertiesKHR*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkDisplayModePropertiesKHR* check_pProperties;
+ check_pProperties = (VkDisplayModePropertiesKHR*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkDisplayModePropertiesKHR(stream, (VkDisplayModePropertiesKHR*)(pProperties + i));
+ }
+ }
+ VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetDisplayModePropertiesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetDisplayModePropertiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkDisplayKHR local_display;
+ VkDisplayModeCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_physicalDevice = physicalDevice;
+ local_display = display;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDisplayModeCreateInfoKHR*)pool->alloc(sizeof(const VkDisplayModeCreateInfoKHR));
+ deepcopy_VkDisplayModeCreateInfoKHR(pool, pCreateInfo, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_884;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_884, 1);
+ countingStream->write((uint64_t*)&cgen_var_884, 1 * 8);
+ uint64_t cgen_var_885;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_885, 1);
+ countingStream->write((uint64_t*)&cgen_var_885, 1 * 8);
+ marshal_VkDisplayModeCreateInfoKHR(countingStream, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_886 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_886);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_887;
+ countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_887, 1);
+ countingStream->write((uint64_t*)&cgen_var_887, 8);
+ }
+ uint32_t packetSize_vkCreateDisplayModeKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDisplayModeKHR = OP_vkCreateDisplayModeKHR;
+ stream->write(&opcode_vkCreateDisplayModeKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDisplayModeKHR, sizeof(uint32_t));
+ uint64_t cgen_var_888;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_888, 1);
+ stream->write((uint64_t*)&cgen_var_888, 1 * 8);
+ uint64_t cgen_var_889;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_889, 1);
+ stream->write((uint64_t*)&cgen_var_889, 1 * 8);
+ marshal_VkDisplayModeCreateInfoKHR(stream, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_890 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_890);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_891;
+ stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_891, 1);
+ stream->write((uint64_t*)&cgen_var_891, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_892;
+ stream->read((uint64_t*)&cgen_var_892, 8);
+ stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_892, (VkDisplayModeKHR*)pMode, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDisplayModeKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateDisplayModeKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkDisplayModeKHR local_mode;
+ uint32_t local_planeIndex;
+ local_physicalDevice = physicalDevice;
+ local_mode = mode;
+ local_planeIndex = planeIndex;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_893;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_893, 1);
+ countingStream->write((uint64_t*)&cgen_var_893, 1 * 8);
+ uint64_t cgen_var_894;
+ countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_894, 1);
+ countingStream->write((uint64_t*)&cgen_var_894, 1 * 8);
+ countingStream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
+ marshal_VkDisplayPlaneCapabilitiesKHR(countingStream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
+ }
+ uint32_t packetSize_vkGetDisplayPlaneCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDisplayPlaneCapabilitiesKHR = OP_vkGetDisplayPlaneCapabilitiesKHR;
+ stream->write(&opcode_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_895;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_895, 1);
+ stream->write((uint64_t*)&cgen_var_895, 1 * 8);
+ uint64_t cgen_var_896;
+ stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_896, 1);
+ stream->write((uint64_t*)&cgen_var_896, 1 * 8);
+ stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
+ marshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
+ unmarshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
+ VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetDisplayPlaneCapabilitiesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkDisplaySurfaceCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDisplaySurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkDisplaySurfaceCreateInfoKHR));
+ deepcopy_VkDisplaySurfaceCreateInfoKHR(pool, pCreateInfo, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_897;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_897, 1);
+ countingStream->write((uint64_t*)&cgen_var_897, 1 * 8);
+ marshal_VkDisplaySurfaceCreateInfoKHR(countingStream, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_898 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_898);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_899;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_899, 1);
+ countingStream->write((uint64_t*)&cgen_var_899, 8);
+ }
+ uint32_t packetSize_vkCreateDisplayPlaneSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDisplayPlaneSurfaceKHR = OP_vkCreateDisplayPlaneSurfaceKHR;
+ stream->write(&opcode_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
+ uint64_t cgen_var_900;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_900, 1);
+ stream->write((uint64_t*)&cgen_var_900, 1 * 8);
+ marshal_VkDisplaySurfaceCreateInfoKHR(stream, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_901 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_901);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_902;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_902, 1);
+ stream->write((uint64_t*)&cgen_var_902, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_903;
+ stream->read((uint64_t*)&cgen_var_903, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_903, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDisplayPlaneSurfaceKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_display_swapchain
+VkResult VkEncoder::vkCreateSharedSwapchainsKHR(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_swapchainCount;
+ VkSwapchainCreateInfoKHR* local_pCreateInfos;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_swapchainCount = swapchainCount;
+ local_pCreateInfos = nullptr;
+ if (pCreateInfos)
+ {
+ local_pCreateInfos = (VkSwapchainCreateInfoKHR*)pool->alloc(((swapchainCount)) * sizeof(const VkSwapchainCreateInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+ {
+ deepcopy_VkSwapchainCreateInfoKHR(pool, 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));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_904;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_904, 1);
+ countingStream->write((uint64_t*)&cgen_var_904, 1 * 8);
+ countingStream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+ {
+ marshal_VkSwapchainCreateInfoKHR(countingStream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_905 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_905);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ if (((swapchainCount)))
+ {
+ uint64_t* cgen_var_906;
+ countingStream->alloc((void**)&cgen_var_906, ((swapchainCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_906, ((swapchainCount)));
+ countingStream->write((uint64_t*)cgen_var_906, ((swapchainCount)) * 8);
+ }
+ }
+ uint32_t packetSize_vkCreateSharedSwapchainsKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateSharedSwapchainsKHR = OP_vkCreateSharedSwapchainsKHR;
+ stream->write(&opcode_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
+ uint64_t cgen_var_907;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_907, 1);
+ stream->write((uint64_t*)&cgen_var_907, 1 * 8);
+ stream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+ {
+ marshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_908 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_908);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ if (((swapchainCount)))
+ {
+ uint64_t* cgen_var_909;
+ stream->alloc((void**)&cgen_var_909, ((swapchainCount)) * 8);
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_909, ((swapchainCount)));
+ stream->write((uint64_t*)cgen_var_909, ((swapchainCount)) * 8);
+ }
+ stream->setHandleMapping(resources->unwrapMapping());
+ if (((swapchainCount)))
+ {
+ uint64_t* cgen_var_910;
+ stream->alloc((void**)&cgen_var_910, ((swapchainCount)) * 8);
+ stream->read((uint64_t*)cgen_var_910, ((swapchainCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_910, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
+ }
+ VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateSharedSwapchainsKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateSharedSwapchainsKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_xlib_surface
+VkResult VkEncoder::vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkXlibSurfaceCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkXlibSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXlibSurfaceCreateInfoKHR));
+ deepcopy_VkXlibSurfaceCreateInfoKHR(pool, pCreateInfo, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_911;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_911, 1);
+ countingStream->write((uint64_t*)&cgen_var_911, 1 * 8);
+ marshal_VkXlibSurfaceCreateInfoKHR(countingStream, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_912 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_912);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_913;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_913, 1);
+ countingStream->write((uint64_t*)&cgen_var_913, 8);
+ }
+ uint32_t packetSize_vkCreateXlibSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateXlibSurfaceKHR = OP_vkCreateXlibSurfaceKHR;
+ stream->write(&opcode_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
+ uint64_t cgen_var_914;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_914, 1);
+ stream->write((uint64_t*)&cgen_var_914, 1 * 8);
+ marshal_VkXlibSurfaceCreateInfoKHR(stream, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_915 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_915);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_916;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_916, 1);
+ stream->write((uint64_t*)&cgen_var_916, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_917;
+ stream->read((uint64_t*)&cgen_var_917, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_917, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateXlibSurfaceKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateXlibSurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ uint32_t local_queueFamilyIndex;
+ VisualID local_visualID;
+ local_physicalDevice = physicalDevice;
+ local_queueFamilyIndex = queueFamilyIndex;
+ local_visualID = visualID;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_918;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_918, 1);
+ countingStream->write((uint64_t*)&cgen_var_918, 1 * 8);
+ countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ countingStream->write((Display*)dpy, sizeof(Display));
+ countingStream->write((VisualID*)&local_visualID, sizeof(VisualID));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR = OP_vkGetPhysicalDeviceXlibPresentationSupportKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
+ uint64_t cgen_var_919;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_919, 1);
+ stream->write((uint64_t*)&cgen_var_919, 1 * 8);
+ stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ stream->write((Display*)dpy, sizeof(Display));
+ stream->write((VisualID*)&local_visualID, sizeof(VisualID));
+ stream->read((Display*)dpy, sizeof(Display));
+ VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ stream->read(&vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_xcb_surface
+VkResult VkEncoder::vkCreateXcbSurfaceKHR(
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkXcbSurfaceCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkXcbSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXcbSurfaceCreateInfoKHR));
+ deepcopy_VkXcbSurfaceCreateInfoKHR(pool, pCreateInfo, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_920;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_920, 1);
+ countingStream->write((uint64_t*)&cgen_var_920, 1 * 8);
+ marshal_VkXcbSurfaceCreateInfoKHR(countingStream, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_921 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_921);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_922;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_922, 1);
+ countingStream->write((uint64_t*)&cgen_var_922, 8);
+ }
+ uint32_t packetSize_vkCreateXcbSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateXcbSurfaceKHR = OP_vkCreateXcbSurfaceKHR;
+ stream->write(&opcode_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
+ uint64_t cgen_var_923;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_923, 1);
+ stream->write((uint64_t*)&cgen_var_923, 1 * 8);
+ marshal_VkXcbSurfaceCreateInfoKHR(stream, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_924 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_924);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_925;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_925, 1);
+ stream->write((uint64_t*)&cgen_var_925, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_926;
+ stream->read((uint64_t*)&cgen_var_926, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_926, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateXcbSurfaceKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateXcbSurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ uint32_t local_queueFamilyIndex;
+ xcb_visualid_t local_visual_id;
+ local_physicalDevice = physicalDevice;
+ local_queueFamilyIndex = queueFamilyIndex;
+ local_visual_id = visual_id;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_927;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_927, 1);
+ countingStream->write((uint64_t*)&cgen_var_927, 1 * 8);
+ countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ countingStream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
+ countingStream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR = OP_vkGetPhysicalDeviceXcbPresentationSupportKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
+ uint64_t cgen_var_928;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_928, 1);
+ stream->write((uint64_t*)&cgen_var_928, 1 * 8);
+ stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ stream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
+ stream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
+ stream->read((xcb_connection_t*)connection, sizeof(xcb_connection_t));
+ VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ stream->read(&vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_wayland_surface
+VkResult VkEncoder::vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkWaylandSurfaceCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkWaylandSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWaylandSurfaceCreateInfoKHR));
+ deepcopy_VkWaylandSurfaceCreateInfoKHR(pool, pCreateInfo, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_929;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_929, 1);
+ countingStream->write((uint64_t*)&cgen_var_929, 1 * 8);
+ marshal_VkWaylandSurfaceCreateInfoKHR(countingStream, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_930 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_930);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_931;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_931, 1);
+ countingStream->write((uint64_t*)&cgen_var_931, 8);
+ }
+ uint32_t packetSize_vkCreateWaylandSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateWaylandSurfaceKHR = OP_vkCreateWaylandSurfaceKHR;
+ stream->write(&opcode_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
+ uint64_t cgen_var_932;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_932, 1);
+ stream->write((uint64_t*)&cgen_var_932, 1 * 8);
+ marshal_VkWaylandSurfaceCreateInfoKHR(stream, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_933 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_933);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_934;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_934, 1);
+ stream->write((uint64_t*)&cgen_var_934, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_935;
+ stream->read((uint64_t*)&cgen_var_935, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_935, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateWaylandSurfaceKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateWaylandSurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ wl_display* display)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ uint32_t local_queueFamilyIndex;
+ local_physicalDevice = physicalDevice;
+ local_queueFamilyIndex = queueFamilyIndex;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_936;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_936, 1);
+ countingStream->write((uint64_t*)&cgen_var_936, 1 * 8);
+ countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ countingStream->write((wl_display*)display, sizeof(wl_display));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR = OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
+ uint64_t cgen_var_937;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_937, 1);
+ stream->write((uint64_t*)&cgen_var_937, 1 * 8);
+ stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ stream->write((wl_display*)display, sizeof(wl_display));
+ stream->read((wl_display*)display, sizeof(wl_display));
+ VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ stream->read(&vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_mir_surface
+VkResult VkEncoder::vkCreateMirSurfaceKHR(
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkMirSurfaceCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkMirSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkMirSurfaceCreateInfoKHR));
+ deepcopy_VkMirSurfaceCreateInfoKHR(pool, pCreateInfo, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_938;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_938, 1);
+ countingStream->write((uint64_t*)&cgen_var_938, 1 * 8);
+ marshal_VkMirSurfaceCreateInfoKHR(countingStream, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_939 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_939);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_940;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_940, 1);
+ countingStream->write((uint64_t*)&cgen_var_940, 8);
+ }
+ uint32_t packetSize_vkCreateMirSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateMirSurfaceKHR = OP_vkCreateMirSurfaceKHR;
+ stream->write(&opcode_vkCreateMirSurfaceKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateMirSurfaceKHR, sizeof(uint32_t));
+ uint64_t cgen_var_941;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_941, 1);
+ stream->write((uint64_t*)&cgen_var_941, 1 * 8);
+ marshal_VkMirSurfaceCreateInfoKHR(stream, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_942 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_942);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_943;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_943, 1);
+ stream->write((uint64_t*)&cgen_var_943, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_944;
+ stream->read((uint64_t*)&cgen_var_944, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_944, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateMirSurfaceKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateMirSurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceMirPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ uint32_t local_queueFamilyIndex;
+ local_physicalDevice = physicalDevice;
+ local_queueFamilyIndex = queueFamilyIndex;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_945;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_945, 1);
+ countingStream->write((uint64_t*)&cgen_var_945, 1 * 8);
+ countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ countingStream->write((MirConnection*)connection, sizeof(MirConnection));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceMirPresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceMirPresentationSupportKHR = OP_vkGetPhysicalDeviceMirPresentationSupportKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceMirPresentationSupportKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceMirPresentationSupportKHR, sizeof(uint32_t));
+ uint64_t cgen_var_946;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_946, 1);
+ stream->write((uint64_t*)&cgen_var_946, 1 * 8);
+ stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ stream->write((MirConnection*)connection, sizeof(MirConnection));
+ stream->read((MirConnection*)connection, sizeof(MirConnection));
+ VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ stream->read(&vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_android_surface
+VkResult VkEncoder::vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkAndroidSurfaceCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkAndroidSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkAndroidSurfaceCreateInfoKHR));
+ deepcopy_VkAndroidSurfaceCreateInfoKHR(pool, pCreateInfo, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_947;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_947, 1);
+ countingStream->write((uint64_t*)&cgen_var_947, 1 * 8);
+ marshal_VkAndroidSurfaceCreateInfoKHR(countingStream, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_948 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_948);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_949;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_949, 1);
+ countingStream->write((uint64_t*)&cgen_var_949, 8);
+ }
+ uint32_t packetSize_vkCreateAndroidSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateAndroidSurfaceKHR = OP_vkCreateAndroidSurfaceKHR;
+ stream->write(&opcode_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
+ uint64_t cgen_var_950;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_950, 1);
+ stream->write((uint64_t*)&cgen_var_950, 1 * 8);
+ marshal_VkAndroidSurfaceCreateInfoKHR(stream, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_951 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_951);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_952;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_952, 1);
+ stream->write((uint64_t*)&cgen_var_952, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_953;
+ stream->read((uint64_t*)&cgen_var_953, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_953, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateAndroidSurfaceKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateAndroidSurfaceKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_win32_surface
+VkResult VkEncoder::vkCreateWin32SurfaceKHR(
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkWin32SurfaceCreateInfoKHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkWin32SurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWin32SurfaceCreateInfoKHR));
+ deepcopy_VkWin32SurfaceCreateInfoKHR(pool, pCreateInfo, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_954;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_954, 1);
+ countingStream->write((uint64_t*)&cgen_var_954, 1 * 8);
+ marshal_VkWin32SurfaceCreateInfoKHR(countingStream, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_955 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_955);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_956;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_956, 1);
+ countingStream->write((uint64_t*)&cgen_var_956, 8);
+ }
+ uint32_t packetSize_vkCreateWin32SurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateWin32SurfaceKHR = OP_vkCreateWin32SurfaceKHR;
+ stream->write(&opcode_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
+ uint64_t cgen_var_957;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_957, 1);
+ stream->write((uint64_t*)&cgen_var_957, 1 * 8);
+ marshal_VkWin32SurfaceCreateInfoKHR(stream, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_958 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_958);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_959;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_959, 1);
+ stream->write((uint64_t*)&cgen_var_959, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_960;
+ stream->read((uint64_t*)&cgen_var_960, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_960, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateWin32SurfaceKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateWin32SurfaceKHR_VkResult_return;
+}
+
+VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ uint32_t local_queueFamilyIndex;
+ local_physicalDevice = physicalDevice;
+ local_queueFamilyIndex = queueFamilyIndex;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_961;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_961, 1);
+ countingStream->write((uint64_t*)&cgen_var_961, 1 * 8);
+ countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR = OP_vkGetPhysicalDeviceWin32PresentationSupportKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
+ uint64_t cgen_var_962;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_962, 1);
+ stream->write((uint64_t*)&cgen_var_962, 1 * 8);
+ stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
+ VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ stream->read(&vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
+}
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_963;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_963, 1);
+ countingStream->write((uint64_t*)&cgen_var_963, 1 * 8);
+ marshal_VkPhysicalDeviceFeatures2(countingStream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceFeatures2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceFeatures2KHR = OP_vkGetPhysicalDeviceFeatures2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_964;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_964, 1);
+ stream->write((uint64_t*)&cgen_var_964, 1 * 8);
+ marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+ unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
+}
+
+void VkEncoder::vkGetPhysicalDeviceProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_965;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_965, 1);
+ countingStream->write((uint64_t*)&cgen_var_965, 1 * 8);
+ marshal_VkPhysicalDeviceProperties2(countingStream, (VkPhysicalDeviceProperties2*)(pProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceProperties2KHR = OP_vkGetPhysicalDeviceProperties2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_966;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_966, 1);
+ stream->write((uint64_t*)&cgen_var_966, 1 * 8);
+ marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
+ unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkFormat local_format;
+ local_physicalDevice = physicalDevice;
+ local_format = format;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_967;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_967, 1);
+ countingStream->write((uint64_t*)&cgen_var_967, 1 * 8);
+ countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ marshal_VkFormatProperties2(countingStream, (VkFormatProperties2*)(pFormatProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceFormatProperties2KHR = OP_vkGetPhysicalDeviceFormatProperties2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_968;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_968, 1);
+ stream->write((uint64_t*)&cgen_var_968, 1 * 8);
+ stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
+ unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceImageFormatInfo2* local_pImageFormatInfo;
+ local_physicalDevice = physicalDevice;
+ local_pImageFormatInfo = nullptr;
+ if (pImageFormatInfo)
+ {
+ local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
+ deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_969;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_969, 1);
+ countingStream->write((uint64_t*)&cgen_var_969, 1 * 8);
+ marshal_VkPhysicalDeviceImageFormatInfo2(countingStream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ marshal_VkImageFormatProperties2(countingStream, (VkImageFormatProperties2*)(pImageFormatProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2KHR = OP_vkGetPhysicalDeviceImageFormatProperties2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_970;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_970, 1);
+ stream->write((uint64_t*)&cgen_var_970, 1 * 8);
+ marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
+ unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
+ VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_971;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_971, 1);
+ countingStream->write((uint64_t*)&cgen_var_971, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_972 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ countingStream->putBe64(cgen_var_972);
+ if (pQueueFamilyPropertyCount)
+ {
+ countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_973 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ countingStream->putBe64(cgen_var_973);
+ if (pQueueFamilyProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ marshal_VkQueueFamilyProperties2(countingStream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR = OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_974;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_974, 1);
+ stream->write((uint64_t*)&cgen_var_974, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_975 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ stream->putBe64(cgen_var_975);
+ if (pQueueFamilyPropertyCount)
+ {
+ stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_976 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ stream->putBe64(cgen_var_976);
+ if (pQueueFamilyProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ marshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pQueueFamilyPropertyCount;
+ check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pQueueFamilyPropertyCount)
+ {
+ if (!(check_pQueueFamilyPropertyCount))
+ {
+ fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkQueueFamilyProperties2* check_pQueueFamilyProperties;
+ check_pQueueFamilyProperties = (VkQueueFamilyProperties2*)(uintptr_t)stream->getBe64();
+ if (pQueueFamilyProperties)
+ {
+ if (!(check_pQueueFamilyProperties))
+ {
+ fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
+ {
+ unmarshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ }
+ }
+}
+
+void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_979;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_979, 1);
+ countingStream->write((uint64_t*)&cgen_var_979, 1 * 8);
+ marshal_VkPhysicalDeviceMemoryProperties2(countingStream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2KHR = OP_vkGetPhysicalDeviceMemoryProperties2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_980;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_980, 1);
+ stream->write((uint64_t*)&cgen_var_980, 1 * 8);
+ marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+ unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+}
+
+void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceSparseImageFormatInfo2* local_pFormatInfo;
+ local_physicalDevice = physicalDevice;
+ local_pFormatInfo = nullptr;
+ if (pFormatInfo)
+ {
+ local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
+ deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_981;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_981, 1);
+ countingStream->write((uint64_t*)&cgen_var_981, 1 * 8);
+ marshal_VkPhysicalDeviceSparseImageFormatInfo2(countingStream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_982 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_982);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_983 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_983);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkSparseImageFormatProperties2(countingStream, (VkSparseImageFormatProperties2*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_984;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_984, 1);
+ stream->write((uint64_t*)&cgen_var_984, 1 * 8);
+ marshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_985 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_985);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_986 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_986);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkSparseImageFormatProperties2* check_pProperties;
+ check_pProperties = (VkSparseImageFormatProperties2*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_KHR_device_group
+void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_heapIndex;
+ uint32_t local_localDeviceIndex;
+ uint32_t local_remoteDeviceIndex;
+ local_device = device;
+ local_heapIndex = heapIndex;
+ local_localDeviceIndex = localDeviceIndex;
+ local_remoteDeviceIndex = remoteDeviceIndex;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_989;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_989, 1);
+ countingStream->write((uint64_t*)&cgen_var_989, 1 * 8);
+ countingStream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
+ countingStream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+ }
+ uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR = OP_vkGetDeviceGroupPeerMemoryFeaturesKHR;
+ stream->write(&opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_990;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_990, 1);
+ stream->write((uint64_t*)&cgen_var_990, 1 * 8);
+ stream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
+ stream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+ stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+}
+
+void VkEncoder::vkCmdSetDeviceMaskKHR(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_deviceMask;
+ local_commandBuffer = commandBuffer;
+ local_deviceMask = deviceMask;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_991;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_991, 1);
+ countingStream->write((uint64_t*)&cgen_var_991, 1 * 8);
+ countingStream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdSetDeviceMaskKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetDeviceMaskKHR = OP_vkCmdSetDeviceMaskKHR;
+ stream->write(&opcode_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
+ uint64_t cgen_var_992;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_992, 1);
+ stream->write((uint64_t*)&cgen_var_992, 1 * 8);
+ stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDispatchBaseKHR(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_baseGroupX;
+ uint32_t local_baseGroupY;
+ uint32_t local_baseGroupZ;
+ uint32_t local_groupCountX;
+ uint32_t local_groupCountY;
+ uint32_t local_groupCountZ;
+ local_commandBuffer = commandBuffer;
+ local_baseGroupX = baseGroupX;
+ local_baseGroupY = baseGroupY;
+ local_baseGroupZ = baseGroupZ;
+ local_groupCountX = groupCountX;
+ local_groupCountY = groupCountY;
+ local_groupCountZ = groupCountZ;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_993;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_993, 1);
+ countingStream->write((uint64_t*)&cgen_var_993, 1 * 8);
+ countingStream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDispatchBaseKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDispatchBaseKHR = OP_vkCmdDispatchBaseKHR;
+ stream->write(&opcode_vkCmdDispatchBaseKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDispatchBaseKHR, sizeof(uint32_t));
+ uint64_t cgen_var_994;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_994, 1);
+ stream->write((uint64_t*)&cgen_var_994, 1 * 8);
+ stream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+void VkEncoder::vkTrimCommandPoolKHR(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkCommandPool local_commandPool;
+ VkCommandPoolTrimFlags local_flags;
+ local_device = device;
+ local_commandPool = commandPool;
+ local_flags = flags;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_995;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_995, 1);
+ countingStream->write((uint64_t*)&cgen_var_995, 1 * 8);
+ uint64_t cgen_var_996;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_996, 1);
+ countingStream->write((uint64_t*)&cgen_var_996, 1 * 8);
+ countingStream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
+ }
+ uint32_t packetSize_vkTrimCommandPoolKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkTrimCommandPoolKHR = OP_vkTrimCommandPoolKHR;
+ stream->write(&opcode_vkTrimCommandPoolKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkTrimCommandPoolKHR, sizeof(uint32_t));
+ uint64_t cgen_var_997;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_997, 1);
+ stream->write((uint64_t*)&cgen_var_997, 1 * 8);
+ uint64_t cgen_var_998;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_998, 1);
+ stream->write((uint64_t*)&cgen_var_998, 1 * 8);
+ stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
+}
+
+#endif
+#ifdef VK_KHR_device_group_creation
+VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ local_instance = instance;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_999;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_999, 1);
+ countingStream->write((uint64_t*)&cgen_var_999, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1000 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+ countingStream->putBe64(cgen_var_1000);
+ if (pPhysicalDeviceGroupCount)
+ {
+ countingStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1001 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+ countingStream->putBe64(cgen_var_1001);
+ if (pPhysicalDeviceGroupProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+ {
+ marshal_VkPhysicalDeviceGroupProperties(countingStream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkEnumeratePhysicalDeviceGroupsKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkEnumeratePhysicalDeviceGroupsKHR = OP_vkEnumeratePhysicalDeviceGroupsKHR;
+ stream->write(&opcode_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1002;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1002, 1);
+ stream->write((uint64_t*)&cgen_var_1002, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1003 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+ stream->putBe64(cgen_var_1003);
+ if (pPhysicalDeviceGroupCount)
+ {
+ stream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1004 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+ stream->putBe64(cgen_var_1004);
+ if (pPhysicalDeviceGroupProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+ {
+ marshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPhysicalDeviceGroupCount;
+ check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPhysicalDeviceGroupCount)
+ {
+ if (!(check_pPhysicalDeviceGroupCount))
+ {
+ fprintf(stderr, "fatal: pPhysicalDeviceGroupCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkPhysicalDeviceGroupProperties* check_pPhysicalDeviceGroupProperties;
+ check_pPhysicalDeviceGroupProperties = (VkPhysicalDeviceGroupProperties*)(uintptr_t)stream->getBe64();
+ if (pPhysicalDeviceGroupProperties)
+ {
+ if (!(check_pPhysicalDeviceGroupProperties))
+ {
+ fprintf(stderr, "fatal: pPhysicalDeviceGroupProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
+ {
+ unmarshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ }
+ }
+ VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceExternalBufferInfo* local_pExternalBufferInfo;
+ local_physicalDevice = physicalDevice;
+ local_pExternalBufferInfo = nullptr;
+ if (pExternalBufferInfo)
+ {
+ local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
+ deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1007;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1007, 1);
+ countingStream->write((uint64_t*)&cgen_var_1007, 1 * 8);
+ marshal_VkPhysicalDeviceExternalBufferInfo(countingStream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ marshal_VkExternalBufferProperties(countingStream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR = OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1008;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1008, 1);
+ stream->write((uint64_t*)&cgen_var_1008, 1 * 8);
+ marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+ unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
+}
+
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+VkResult VkEncoder::vkGetMemoryWin32HandleKHR(
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkMemoryGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
+ local_device = device;
+ local_pGetWin32HandleInfo = nullptr;
+ if (pGetWin32HandleInfo)
+ {
+ local_pGetWin32HandleInfo = (VkMemoryGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkMemoryGetWin32HandleInfoKHR));
+ deepcopy_VkMemoryGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1009;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1009, 1);
+ countingStream->write((uint64_t*)&cgen_var_1009, 1 * 8);
+ marshal_VkMemoryGetWin32HandleInfoKHR(countingStream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
+ }
+ uint32_t packetSize_vkGetMemoryWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetMemoryWin32HandleKHR = OP_vkGetMemoryWin32HandleKHR;
+ stream->write(&opcode_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1010;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1010, 1);
+ stream->write((uint64_t*)&cgen_var_1010, 1 * 8);
+ marshal_VkMemoryGetWin32HandleInfoKHR(stream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ stream->write((HANDLE*)pHandle, sizeof(HANDLE));
+ stream->read((HANDLE*)pHandle, sizeof(HANDLE));
+ VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetMemoryWin32HandleKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetMemoryWin32HandleKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkExternalMemoryHandleTypeFlagBits local_handleType;
+ HANDLE local_handle;
+ local_device = device;
+ local_handleType = handleType;
+ local_handle = handle;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1011;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1011, 1);
+ countingStream->write((uint64_t*)&cgen_var_1011, 1 * 8);
+ countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ countingStream->write((HANDLE*)&local_handle, sizeof(HANDLE));
+ marshal_VkMemoryWin32HandlePropertiesKHR(countingStream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
+ }
+ uint32_t packetSize_vkGetMemoryWin32HandlePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetMemoryWin32HandlePropertiesKHR = OP_vkGetMemoryWin32HandlePropertiesKHR;
+ stream->write(&opcode_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1012;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1012, 1);
+ stream->write((uint64_t*)&cgen_var_1012, 1 * 8);
+ stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ stream->write((HANDLE*)&local_handle, sizeof(HANDLE));
+ marshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
+ unmarshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
+ VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetMemoryWin32HandlePropertiesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+VkResult VkEncoder::vkGetMemoryFdKHR(
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkMemoryGetFdInfoKHR* local_pGetFdInfo;
+ local_device = device;
+ local_pGetFdInfo = nullptr;
+ if (pGetFdInfo)
+ {
+ local_pGetFdInfo = (VkMemoryGetFdInfoKHR*)pool->alloc(sizeof(const VkMemoryGetFdInfoKHR));
+ deepcopy_VkMemoryGetFdInfoKHR(pool, pGetFdInfo, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1013;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1013, 1);
+ countingStream->write((uint64_t*)&cgen_var_1013, 1 * 8);
+ marshal_VkMemoryGetFdInfoKHR(countingStream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+ countingStream->write((int*)pFd, sizeof(int));
+ }
+ uint32_t packetSize_vkGetMemoryFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetMemoryFdKHR = OP_vkGetMemoryFdKHR;
+ stream->write(&opcode_vkGetMemoryFdKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetMemoryFdKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1014;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1014, 1);
+ stream->write((uint64_t*)&cgen_var_1014, 1 * 8);
+ marshal_VkMemoryGetFdInfoKHR(stream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+ stream->write((int*)pFd, sizeof(int));
+ stream->read((int*)pFd, sizeof(int));
+ VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetMemoryFdKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetMemoryFdKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetMemoryFdPropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkExternalMemoryHandleTypeFlagBits local_handleType;
+ int local_fd;
+ local_device = device;
+ local_handleType = handleType;
+ local_fd = fd;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1015;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1015, 1);
+ countingStream->write((uint64_t*)&cgen_var_1015, 1 * 8);
+ countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ countingStream->write((int*)&local_fd, sizeof(int));
+ marshal_VkMemoryFdPropertiesKHR(countingStream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
+ }
+ uint32_t packetSize_vkGetMemoryFdPropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetMemoryFdPropertiesKHR = OP_vkGetMemoryFdPropertiesKHR;
+ stream->write(&opcode_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1016;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1016, 1);
+ stream->write((uint64_t*)&cgen_var_1016, 1 * 8);
+ stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ stream->write((int*)&local_fd, sizeof(int));
+ marshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
+ unmarshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
+ VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetMemoryFdPropertiesKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceExternalSemaphoreInfo* local_pExternalSemaphoreInfo;
+ local_physicalDevice = physicalDevice;
+ local_pExternalSemaphoreInfo = nullptr;
+ if (pExternalSemaphoreInfo)
+ {
+ local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
+ deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1017;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1017, 1);
+ countingStream->write((uint64_t*)&cgen_var_1017, 1 * 8);
+ marshal_VkPhysicalDeviceExternalSemaphoreInfo(countingStream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ marshal_VkExternalSemaphoreProperties(countingStream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1018;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1018, 1);
+ stream->write((uint64_t*)&cgen_var_1018, 1 * 8);
+ marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+ unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImportSemaphoreWin32HandleInfoKHR* local_pImportSemaphoreWin32HandleInfo;
+ local_device = device;
+ local_pImportSemaphoreWin32HandleInfo = nullptr;
+ if (pImportSemaphoreWin32HandleInfo)
+ {
+ local_pImportSemaphoreWin32HandleInfo = (VkImportSemaphoreWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreWin32HandleInfoKHR));
+ deepcopy_VkImportSemaphoreWin32HandleInfoKHR(pool, pImportSemaphoreWin32HandleInfo, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1019;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1019, 1);
+ countingStream->write((uint64_t*)&cgen_var_1019, 1 * 8);
+ marshal_VkImportSemaphoreWin32HandleInfoKHR(countingStream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+ }
+ uint32_t packetSize_vkImportSemaphoreWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkImportSemaphoreWin32HandleKHR = OP_vkImportSemaphoreWin32HandleKHR;
+ stream->write(&opcode_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1020;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1020, 1);
+ stream->write((uint64_t*)&cgen_var_1020, 1 * 8);
+ marshal_VkImportSemaphoreWin32HandleInfoKHR(stream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+ VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkImportSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSemaphoreGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
+ local_device = device;
+ local_pGetWin32HandleInfo = nullptr;
+ if (pGetWin32HandleInfo)
+ {
+ local_pGetWin32HandleInfo = (VkSemaphoreGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetWin32HandleInfoKHR));
+ deepcopy_VkSemaphoreGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1021;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1021, 1);
+ countingStream->write((uint64_t*)&cgen_var_1021, 1 * 8);
+ marshal_VkSemaphoreGetWin32HandleInfoKHR(countingStream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
+ }
+ uint32_t packetSize_vkGetSemaphoreWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetSemaphoreWin32HandleKHR = OP_vkGetSemaphoreWin32HandleKHR;
+ stream->write(&opcode_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1022;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1022, 1);
+ stream->write((uint64_t*)&cgen_var_1022, 1 * 8);
+ marshal_VkSemaphoreGetWin32HandleInfoKHR(stream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ stream->write((HANDLE*)pHandle, sizeof(HANDLE));
+ stream->read((HANDLE*)pHandle, sizeof(HANDLE));
+ VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+VkResult VkEncoder::vkImportSemaphoreFdKHR(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImportSemaphoreFdInfoKHR* local_pImportSemaphoreFdInfo;
+ local_device = device;
+ local_pImportSemaphoreFdInfo = nullptr;
+ if (pImportSemaphoreFdInfo)
+ {
+ local_pImportSemaphoreFdInfo = (VkImportSemaphoreFdInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreFdInfoKHR));
+ deepcopy_VkImportSemaphoreFdInfoKHR(pool, pImportSemaphoreFdInfo, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1023;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1023, 1);
+ countingStream->write((uint64_t*)&cgen_var_1023, 1 * 8);
+ marshal_VkImportSemaphoreFdInfoKHR(countingStream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+ }
+ uint32_t packetSize_vkImportSemaphoreFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkImportSemaphoreFdKHR = OP_vkImportSemaphoreFdKHR;
+ stream->write(&opcode_vkImportSemaphoreFdKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkImportSemaphoreFdKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1024;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1024, 1);
+ stream->write((uint64_t*)&cgen_var_1024, 1 * 8);
+ marshal_VkImportSemaphoreFdInfoKHR(stream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+ VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkImportSemaphoreFdKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetSemaphoreFdKHR(
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSemaphoreGetFdInfoKHR* local_pGetFdInfo;
+ local_device = device;
+ local_pGetFdInfo = nullptr;
+ if (pGetFdInfo)
+ {
+ local_pGetFdInfo = (VkSemaphoreGetFdInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetFdInfoKHR));
+ deepcopy_VkSemaphoreGetFdInfoKHR(pool, pGetFdInfo, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1025;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1025, 1);
+ countingStream->write((uint64_t*)&cgen_var_1025, 1 * 8);
+ marshal_VkSemaphoreGetFdInfoKHR(countingStream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+ countingStream->write((int*)pFd, sizeof(int));
+ }
+ uint32_t packetSize_vkGetSemaphoreFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetSemaphoreFdKHR = OP_vkGetSemaphoreFdKHR;
+ stream->write(&opcode_vkGetSemaphoreFdKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetSemaphoreFdKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1026;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1026, 1);
+ stream->write((uint64_t*)&cgen_var_1026, 1 * 8);
+ marshal_VkSemaphoreGetFdInfoKHR(stream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+ stream->write((int*)pFd, sizeof(int));
+ stream->read((int*)pFd, sizeof(int));
+ VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetSemaphoreFdKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void VkEncoder::vkCmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkPipelineBindPoint local_pipelineBindPoint;
+ VkPipelineLayout local_layout;
+ uint32_t local_set;
+ uint32_t local_descriptorWriteCount;
+ VkWriteDescriptorSet* local_pDescriptorWrites;
+ local_commandBuffer = commandBuffer;
+ local_pipelineBindPoint = pipelineBindPoint;
+ local_layout = layout;
+ local_set = set;
+ local_descriptorWriteCount = descriptorWriteCount;
+ local_pDescriptorWrites = nullptr;
+ if (pDescriptorWrites)
+ {
+ local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+ {
+ deepcopy_VkWriteDescriptorSet(pool, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1027;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1027, 1);
+ countingStream->write((uint64_t*)&cgen_var_1027, 1 * 8);
+ countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ uint64_t cgen_var_1028;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1028, 1);
+ countingStream->write((uint64_t*)&cgen_var_1028, 1 * 8);
+ countingStream->write((uint32_t*)&local_set, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+ {
+ marshal_VkWriteDescriptorSet(countingStream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ }
+ }
+ uint32_t packetSize_vkCmdPushDescriptorSetKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdPushDescriptorSetKHR = OP_vkCmdPushDescriptorSetKHR;
+ stream->write(&opcode_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1029;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1029, 1);
+ stream->write((uint64_t*)&cgen_var_1029, 1 * 8);
+ stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ uint64_t cgen_var_1030;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1030, 1);
+ stream->write((uint64_t*)&cgen_var_1030, 1 * 8);
+ stream->write((uint32_t*)&local_set, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
+ {
+ marshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ }
+}
+
+void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR(
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+ VkPipelineLayout local_layout;
+ uint32_t local_set;
+ void* local_pData;
+ local_commandBuffer = commandBuffer;
+ local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+ local_layout = layout;
+ local_set = set;
+ local_pData = nullptr;
+ if (pData)
+ {
+ local_pData = (void*)pool->dupArray(pData, sizeof(const uint8_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1031;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1031, 1);
+ countingStream->write((uint64_t*)&cgen_var_1031, 1 * 8);
+ uint64_t cgen_var_1032;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1032, 1);
+ countingStream->write((uint64_t*)&cgen_var_1032, 1 * 8);
+ uint64_t cgen_var_1033;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1033, 1);
+ countingStream->write((uint64_t*)&cgen_var_1033, 1 * 8);
+ countingStream->write((uint32_t*)&local_set, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1034 = (uint64_t)(uintptr_t)local_pData;
+ countingStream->putBe64(cgen_var_1034);
+ if (local_pData)
+ {
+ countingStream->write((void*)local_pData, sizeof(uint8_t));
+ }
+ }
+ uint32_t packetSize_vkCmdPushDescriptorSetWithTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdPushDescriptorSetWithTemplateKHR = OP_vkCmdPushDescriptorSetWithTemplateKHR;
+ stream->write(&opcode_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1035;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1035, 1);
+ stream->write((uint64_t*)&cgen_var_1035, 1 * 8);
+ uint64_t cgen_var_1036;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1036, 1);
+ stream->write((uint64_t*)&cgen_var_1036, 1 * 8);
+ uint64_t cgen_var_1037;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1037, 1);
+ stream->write((uint64_t*)&cgen_var_1037, 1 * 8);
+ stream->write((uint32_t*)&local_set, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1038 = (uint64_t)(uintptr_t)local_pData;
+ stream->putBe64(cgen_var_1038);
+ if (local_pData)
+ {
+ stream->write((void*)local_pData, sizeof(uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorUpdateTemplateCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
+ deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1039;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1039, 1);
+ countingStream->write((uint64_t*)&cgen_var_1039, 1 * 8);
+ marshal_VkDescriptorUpdateTemplateCreateInfo(countingStream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1040 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1040);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1041;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1041, 1);
+ countingStream->write((uint64_t*)&cgen_var_1041, 8);
+ }
+ uint32_t packetSize_vkCreateDescriptorUpdateTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDescriptorUpdateTemplateKHR = OP_vkCreateDescriptorUpdateTemplateKHR;
+ stream->write(&opcode_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1042;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1042, 1);
+ stream->write((uint64_t*)&cgen_var_1042, 1 * 8);
+ marshal_VkDescriptorUpdateTemplateCreateInfo(stream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1043 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1043);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1044;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1044, 1);
+ stream->write((uint64_t*)&cgen_var_1044, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_1045;
+ stream->read((uint64_t*)&cgen_var_1045, 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_1045, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+ VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDescriptorUpdateTemplateKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1046;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1046, 1);
+ countingStream->write((uint64_t*)&cgen_var_1046, 1 * 8);
+ uint64_t cgen_var_1047;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1047, 1);
+ countingStream->write((uint64_t*)&cgen_var_1047, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1048 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1048);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyDescriptorUpdateTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyDescriptorUpdateTemplateKHR = OP_vkDestroyDescriptorUpdateTemplateKHR;
+ stream->write(&opcode_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1049;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1049, 1);
+ stream->write((uint64_t*)&cgen_var_1049, 1 * 8);
+ uint64_t cgen_var_1050;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1050, 1);
+ stream->write((uint64_t*)&cgen_var_1050, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1051 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1051);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+}
+
+void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorSet local_descriptorSet;
+ VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+ void* local_pData;
+ local_device = device;
+ local_descriptorSet = descriptorSet;
+ local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+ local_pData = nullptr;
+ if (pData)
+ {
+ local_pData = (void*)pool->dupArray(pData, sizeof(const uint8_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1052;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1052, 1);
+ countingStream->write((uint64_t*)&cgen_var_1052, 1 * 8);
+ uint64_t cgen_var_1053;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1053, 1);
+ countingStream->write((uint64_t*)&cgen_var_1053, 1 * 8);
+ uint64_t cgen_var_1054;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1054, 1);
+ countingStream->write((uint64_t*)&cgen_var_1054, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1055 = (uint64_t)(uintptr_t)local_pData;
+ countingStream->putBe64(cgen_var_1055);
+ if (local_pData)
+ {
+ countingStream->write((void*)local_pData, sizeof(uint8_t));
+ }
+ }
+ uint32_t packetSize_vkUpdateDescriptorSetWithTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkUpdateDescriptorSetWithTemplateKHR = OP_vkUpdateDescriptorSetWithTemplateKHR;
+ stream->write(&opcode_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1056;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1056, 1);
+ stream->write((uint64_t*)&cgen_var_1056, 1 * 8);
+ uint64_t cgen_var_1057;
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1057, 1);
+ stream->write((uint64_t*)&cgen_var_1057, 1 * 8);
+ uint64_t cgen_var_1058;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1058, 1);
+ stream->write((uint64_t*)&cgen_var_1058, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1059 = (uint64_t)(uintptr_t)local_pData;
+ stream->putBe64(cgen_var_1059);
+ if (local_pData)
+ {
+ stream->write((void*)local_pData, sizeof(uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_KHR_create_renderpass2
+VkResult VkEncoder::vkCreateRenderPass2KHR(
+ VkDevice device,
+ const VkRenderPassCreateInfo2KHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkRenderPassCreateInfo2KHR* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkRenderPassCreateInfo2KHR*)pool->alloc(sizeof(const VkRenderPassCreateInfo2KHR));
+ deepcopy_VkRenderPassCreateInfo2KHR(pool, pCreateInfo, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1060;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1060, 1);
+ countingStream->write((uint64_t*)&cgen_var_1060, 1 * 8);
+ marshal_VkRenderPassCreateInfo2KHR(countingStream, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1061 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1061);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1062;
+ countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1062, 1);
+ countingStream->write((uint64_t*)&cgen_var_1062, 8);
+ }
+ uint32_t packetSize_vkCreateRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateRenderPass2KHR = OP_vkCreateRenderPass2KHR;
+ stream->write(&opcode_vkCreateRenderPass2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateRenderPass2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1063;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1063, 1);
+ stream->write((uint64_t*)&cgen_var_1063, 1 * 8);
+ marshal_VkRenderPassCreateInfo2KHR(stream, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1064 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1064);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1065;
+ stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1065, 1);
+ stream->write((uint64_t*)&cgen_var_1065, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_1066;
+ stream->read((uint64_t*)&cgen_var_1066, 8);
+ stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_1066, (VkRenderPass*)pRenderPass, 1);
+ VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateRenderPass2KHR_VkResult_return;
+}
+
+void VkEncoder::vkCmdBeginRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkRenderPassBeginInfo* local_pRenderPassBegin;
+ VkSubpassBeginInfoKHR* local_pSubpassBeginInfo;
+ local_commandBuffer = commandBuffer;
+ local_pRenderPassBegin = nullptr;
+ if (pRenderPassBegin)
+ {
+ local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
+ deepcopy_VkRenderPassBeginInfo(pool, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ }
+ local_pSubpassBeginInfo = nullptr;
+ if (pSubpassBeginInfo)
+ {
+ local_pSubpassBeginInfo = (VkSubpassBeginInfoKHR*)pool->alloc(sizeof(const VkSubpassBeginInfoKHR));
+ deepcopy_VkSubpassBeginInfoKHR(pool, pSubpassBeginInfo, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1067;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1067, 1);
+ countingStream->write((uint64_t*)&cgen_var_1067, 1 * 8);
+ marshal_VkRenderPassBeginInfo(countingStream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ marshal_VkSubpassBeginInfoKHR(countingStream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+ }
+ uint32_t packetSize_vkCmdBeginRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBeginRenderPass2KHR = OP_vkCmdBeginRenderPass2KHR;
+ stream->write(&opcode_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1068;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1068, 1);
+ stream->write((uint64_t*)&cgen_var_1068, 1 * 8);
+ marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+}
+
+void VkEncoder::vkCmdNextSubpass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkSubpassBeginInfoKHR* local_pSubpassBeginInfo;
+ VkSubpassEndInfoKHR* local_pSubpassEndInfo;
+ local_commandBuffer = commandBuffer;
+ local_pSubpassBeginInfo = nullptr;
+ if (pSubpassBeginInfo)
+ {
+ local_pSubpassBeginInfo = (VkSubpassBeginInfoKHR*)pool->alloc(sizeof(const VkSubpassBeginInfoKHR));
+ deepcopy_VkSubpassBeginInfoKHR(pool, pSubpassBeginInfo, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+ }
+ local_pSubpassEndInfo = nullptr;
+ if (pSubpassEndInfo)
+ {
+ local_pSubpassEndInfo = (VkSubpassEndInfoKHR*)pool->alloc(sizeof(const VkSubpassEndInfoKHR));
+ deepcopy_VkSubpassEndInfoKHR(pool, pSubpassEndInfo, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1069;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1069, 1);
+ countingStream->write((uint64_t*)&cgen_var_1069, 1 * 8);
+ marshal_VkSubpassBeginInfoKHR(countingStream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+ marshal_VkSubpassEndInfoKHR(countingStream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+ }
+ uint32_t packetSize_vkCmdNextSubpass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdNextSubpass2KHR = OP_vkCmdNextSubpass2KHR;
+ stream->write(&opcode_vkCmdNextSubpass2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdNextSubpass2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1070;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1070, 1);
+ stream->write((uint64_t*)&cgen_var_1070, 1 * 8);
+ marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
+ marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+}
+
+void VkEncoder::vkCmdEndRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkSubpassEndInfoKHR* local_pSubpassEndInfo;
+ local_commandBuffer = commandBuffer;
+ local_pSubpassEndInfo = nullptr;
+ if (pSubpassEndInfo)
+ {
+ local_pSubpassEndInfo = (VkSubpassEndInfoKHR*)pool->alloc(sizeof(const VkSubpassEndInfoKHR));
+ deepcopy_VkSubpassEndInfoKHR(pool, pSubpassEndInfo, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1071;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1071, 1);
+ countingStream->write((uint64_t*)&cgen_var_1071, 1 * 8);
+ marshal_VkSubpassEndInfoKHR(countingStream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+ }
+ uint32_t packetSize_vkCmdEndRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdEndRenderPass2KHR = OP_vkCmdEndRenderPass2KHR;
+ stream->write(&opcode_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1072;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1072, 1);
+ stream->write((uint64_t*)&cgen_var_1072, 1 * 8);
+ marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
+}
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+VkResult VkEncoder::vkGetSwapchainStatusKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSwapchainKHR local_swapchain;
+ local_device = device;
+ local_swapchain = swapchain;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1073;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1073, 1);
+ countingStream->write((uint64_t*)&cgen_var_1073, 1 * 8);
+ uint64_t cgen_var_1074;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1074, 1);
+ countingStream->write((uint64_t*)&cgen_var_1074, 1 * 8);
+ }
+ uint32_t packetSize_vkGetSwapchainStatusKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetSwapchainStatusKHR = OP_vkGetSwapchainStatusKHR;
+ stream->write(&opcode_vkGetSwapchainStatusKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetSwapchainStatusKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1075;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1075, 1);
+ stream->write((uint64_t*)&cgen_var_1075, 1 * 8);
+ uint64_t cgen_var_1076;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1076, 1);
+ stream->write((uint64_t*)&cgen_var_1076, 1 * 8);
+ VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetSwapchainStatusKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetSwapchainStatusKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceExternalFenceInfo* local_pExternalFenceInfo;
+ local_physicalDevice = physicalDevice;
+ local_pExternalFenceInfo = nullptr;
+ if (pExternalFenceInfo)
+ {
+ local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
+ deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1077;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1077, 1);
+ countingStream->write((uint64_t*)&cgen_var_1077, 1 * 8);
+ marshal_VkPhysicalDeviceExternalFenceInfo(countingStream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ marshal_VkExternalFenceProperties(countingStream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR = OP_vkGetPhysicalDeviceExternalFencePropertiesKHR;
+ stream->write(&opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1078;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1078, 1);
+ stream->write((uint64_t*)&cgen_var_1078, 1 * 8);
+ marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+ unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
+}
+
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+VkResult VkEncoder::vkImportFenceWin32HandleKHR(
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImportFenceWin32HandleInfoKHR* local_pImportFenceWin32HandleInfo;
+ local_device = device;
+ local_pImportFenceWin32HandleInfo = nullptr;
+ if (pImportFenceWin32HandleInfo)
+ {
+ local_pImportFenceWin32HandleInfo = (VkImportFenceWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportFenceWin32HandleInfoKHR));
+ deepcopy_VkImportFenceWin32HandleInfoKHR(pool, pImportFenceWin32HandleInfo, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1079;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1079, 1);
+ countingStream->write((uint64_t*)&cgen_var_1079, 1 * 8);
+ marshal_VkImportFenceWin32HandleInfoKHR(countingStream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+ }
+ uint32_t packetSize_vkImportFenceWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkImportFenceWin32HandleKHR = OP_vkImportFenceWin32HandleKHR;
+ stream->write(&opcode_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1080;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1080, 1);
+ stream->write((uint64_t*)&cgen_var_1080, 1 * 8);
+ marshal_VkImportFenceWin32HandleInfoKHR(stream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+ VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkImportFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkImportFenceWin32HandleKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetFenceWin32HandleKHR(
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkFenceGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
+ local_device = device;
+ local_pGetWin32HandleInfo = nullptr;
+ if (pGetWin32HandleInfo)
+ {
+ local_pGetWin32HandleInfo = (VkFenceGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkFenceGetWin32HandleInfoKHR));
+ deepcopy_VkFenceGetWin32HandleInfoKHR(pool, pGetWin32HandleInfo, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1081;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1081, 1);
+ countingStream->write((uint64_t*)&cgen_var_1081, 1 * 8);
+ marshal_VkFenceGetWin32HandleInfoKHR(countingStream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
+ }
+ uint32_t packetSize_vkGetFenceWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetFenceWin32HandleKHR = OP_vkGetFenceWin32HandleKHR;
+ stream->write(&opcode_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1082;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1082, 1);
+ stream->write((uint64_t*)&cgen_var_1082, 1 * 8);
+ marshal_VkFenceGetWin32HandleInfoKHR(stream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ stream->write((HANDLE*)pHandle, sizeof(HANDLE));
+ stream->read((HANDLE*)pHandle, sizeof(HANDLE));
+ VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetFenceWin32HandleKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+VkResult VkEncoder::vkImportFenceFdKHR(
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImportFenceFdInfoKHR* local_pImportFenceFdInfo;
+ local_device = device;
+ local_pImportFenceFdInfo = nullptr;
+ if (pImportFenceFdInfo)
+ {
+ local_pImportFenceFdInfo = (VkImportFenceFdInfoKHR*)pool->alloc(sizeof(const VkImportFenceFdInfoKHR));
+ deepcopy_VkImportFenceFdInfoKHR(pool, pImportFenceFdInfo, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1083;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1083, 1);
+ countingStream->write((uint64_t*)&cgen_var_1083, 1 * 8);
+ marshal_VkImportFenceFdInfoKHR(countingStream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+ }
+ uint32_t packetSize_vkImportFenceFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkImportFenceFdKHR = OP_vkImportFenceFdKHR;
+ stream->write(&opcode_vkImportFenceFdKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkImportFenceFdKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1084;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1084, 1);
+ stream->write((uint64_t*)&cgen_var_1084, 1 * 8);
+ marshal_VkImportFenceFdInfoKHR(stream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+ VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkImportFenceFdKHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetFenceFdKHR(
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkFenceGetFdInfoKHR* local_pGetFdInfo;
+ local_device = device;
+ local_pGetFdInfo = nullptr;
+ if (pGetFdInfo)
+ {
+ local_pGetFdInfo = (VkFenceGetFdInfoKHR*)pool->alloc(sizeof(const VkFenceGetFdInfoKHR));
+ deepcopy_VkFenceGetFdInfoKHR(pool, pGetFdInfo, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1085;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1085, 1);
+ countingStream->write((uint64_t*)&cgen_var_1085, 1 * 8);
+ marshal_VkFenceGetFdInfoKHR(countingStream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+ countingStream->write((int*)pFd, sizeof(int));
+ }
+ uint32_t packetSize_vkGetFenceFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetFenceFdKHR = OP_vkGetFenceFdKHR;
+ stream->write(&opcode_vkGetFenceFdKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetFenceFdKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1086;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1086, 1);
+ stream->write((uint64_t*)&cgen_var_1086, 1 * 8);
+ marshal_VkFenceGetFdInfoKHR(stream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+ stream->write((int*)pFd, sizeof(int));
+ stream->read((int*)pFd, sizeof(int));
+ VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetFenceFdKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetFenceFdKHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceSurfaceInfo2KHR* local_pSurfaceInfo;
+ local_physicalDevice = physicalDevice;
+ local_pSurfaceInfo = nullptr;
+ if (pSurfaceInfo)
+ {
+ local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1087;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1087, 1);
+ countingStream->write((uint64_t*)&cgen_var_1087, 1 * 8);
+ marshal_VkPhysicalDeviceSurfaceInfo2KHR(countingStream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ marshal_VkSurfaceCapabilities2KHR(countingStream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR = OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1088;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1088, 1);
+ stream->write((uint64_t*)&cgen_var_1088, 1 * 8);
+ marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ marshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
+ unmarshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkPhysicalDeviceSurfaceInfo2KHR* local_pSurfaceInfo;
+ local_physicalDevice = physicalDevice;
+ local_pSurfaceInfo = nullptr;
+ if (pSurfaceInfo)
+ {
+ local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1089;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1089, 1);
+ countingStream->write((uint64_t*)&cgen_var_1089, 1 * 8);
+ marshal_VkPhysicalDeviceSurfaceInfo2KHR(countingStream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1090 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+ countingStream->putBe64(cgen_var_1090);
+ if (pSurfaceFormatCount)
+ {
+ countingStream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1091 = (uint64_t)(uintptr_t)pSurfaceFormats;
+ countingStream->putBe64(cgen_var_1091);
+ if (pSurfaceFormats)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+ {
+ marshal_VkSurfaceFormat2KHR(countingStream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceFormats2KHR = OP_vkGetPhysicalDeviceSurfaceFormats2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1092;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1092, 1);
+ stream->write((uint64_t*)&cgen_var_1092, 1 * 8);
+ marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1093 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+ stream->putBe64(cgen_var_1093);
+ if (pSurfaceFormatCount)
+ {
+ stream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1094 = (uint64_t)(uintptr_t)pSurfaceFormats;
+ stream->putBe64(cgen_var_1094);
+ if (pSurfaceFormats)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+ {
+ marshal_VkSurfaceFormat2KHR(stream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pSurfaceFormatCount;
+ check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pSurfaceFormatCount)
+ {
+ if (!(check_pSurfaceFormatCount))
+ {
+ fprintf(stderr, "fatal: pSurfaceFormatCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkSurfaceFormat2KHR* check_pSurfaceFormats;
+ check_pSurfaceFormats = (VkSurfaceFormat2KHR*)(uintptr_t)stream->getBe64();
+ if (pSurfaceFormats)
+ {
+ if (!(check_pSurfaceFormats))
+ {
+ fprintf(stderr, "fatal: pSurfaceFormats inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
+ {
+ unmarshal_VkSurfaceFormat2KHR(stream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+ }
+ }
+ VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1097;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1097, 1);
+ countingStream->write((uint64_t*)&cgen_var_1097, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1098 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_1098);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1099 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_1099);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayProperties2KHR(countingStream, (VkDisplayProperties2KHR*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceDisplayProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceDisplayProperties2KHR = OP_vkGetPhysicalDeviceDisplayProperties2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1100;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1100, 1);
+ stream->write((uint64_t*)&cgen_var_1100, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1101 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_1101);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1102 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_1102);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayProperties2KHR(stream, (VkDisplayProperties2KHR*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkDisplayProperties2KHR* check_pProperties;
+ check_pProperties = (VkDisplayProperties2KHR*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkDisplayProperties2KHR(stream, (VkDisplayProperties2KHR*)(pProperties + i));
+ }
+ }
+ VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1105;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1105, 1);
+ countingStream->write((uint64_t*)&cgen_var_1105, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1106 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_1106);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1107 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_1107);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayPlaneProperties2KHR(countingStream, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+ stream->write(&opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1108;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1108, 1);
+ stream->write((uint64_t*)&cgen_var_1108, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1109 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_1109);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1110 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_1110);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayPlaneProperties2KHR(stream, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkDisplayPlaneProperties2KHR* check_pProperties;
+ check_pProperties = (VkDisplayPlaneProperties2KHR*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkDisplayPlaneProperties2KHR(stream, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+ }
+ }
+ VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayModeProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkDisplayKHR local_display;
+ local_physicalDevice = physicalDevice;
+ local_display = display;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1113;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1113, 1);
+ countingStream->write((uint64_t*)&cgen_var_1113, 1 * 8);
+ uint64_t cgen_var_1114;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1114, 1);
+ countingStream->write((uint64_t*)&cgen_var_1114, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1115 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_1115);
+ if (pPropertyCount)
+ {
+ countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1116 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_1116);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayModeProperties2KHR(countingStream, (VkDisplayModeProperties2KHR*)(pProperties + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetDisplayModeProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDisplayModeProperties2KHR = OP_vkGetDisplayModeProperties2KHR;
+ stream->write(&opcode_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1117;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1117, 1);
+ stream->write((uint64_t*)&cgen_var_1117, 1 * 8);
+ uint64_t cgen_var_1118;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1118, 1);
+ stream->write((uint64_t*)&cgen_var_1118, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1119 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_1119);
+ if (pPropertyCount)
+ {
+ stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1120 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_1120);
+ if (pProperties)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ marshal_VkDisplayModeProperties2KHR(stream, (VkDisplayModeProperties2KHR*)(pProperties + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPropertyCount;
+ check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPropertyCount)
+ {
+ if (!(check_pPropertyCount))
+ {
+ fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkDisplayModeProperties2KHR* check_pProperties;
+ check_pProperties = (VkDisplayModeProperties2KHR*)(uintptr_t)stream->getBe64();
+ if (pProperties)
+ {
+ if (!(check_pProperties))
+ {
+ fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
+ {
+ unmarshal_VkDisplayModeProperties2KHR(stream, (VkDisplayModeProperties2KHR*)(pProperties + i));
+ }
+ }
+ VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetDisplayModeProperties2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetDisplayModeProperties2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkDisplayPlaneInfo2KHR* local_pDisplayPlaneInfo;
+ local_physicalDevice = physicalDevice;
+ local_pDisplayPlaneInfo = nullptr;
+ if (pDisplayPlaneInfo)
+ {
+ local_pDisplayPlaneInfo = (VkDisplayPlaneInfo2KHR*)pool->alloc(sizeof(const VkDisplayPlaneInfo2KHR));
+ deepcopy_VkDisplayPlaneInfo2KHR(pool, pDisplayPlaneInfo, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1123;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1123, 1);
+ countingStream->write((uint64_t*)&cgen_var_1123, 1 * 8);
+ marshal_VkDisplayPlaneInfo2KHR(countingStream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+ marshal_VkDisplayPlaneCapabilities2KHR(countingStream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
+ }
+ uint32_t packetSize_vkGetDisplayPlaneCapabilities2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDisplayPlaneCapabilities2KHR = OP_vkGetDisplayPlaneCapabilities2KHR;
+ stream->write(&opcode_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1124;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1124, 1);
+ stream->write((uint64_t*)&cgen_var_1124, 1 * 8);
+ marshal_VkDisplayPlaneInfo2KHR(stream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+ marshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
+ unmarshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
+ VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkGetDisplayPlaneCapabilities2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+void VkEncoder::vkGetImageMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImageMemoryRequirementsInfo2* local_pInfo;
+ local_device = device;
+ local_pInfo = nullptr;
+ if (pInfo)
+ {
+ local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
+ deepcopy_VkImageMemoryRequirementsInfo2(pool, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1125;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1125, 1);
+ countingStream->write((uint64_t*)&cgen_var_1125, 1 * 8);
+ marshal_VkImageMemoryRequirementsInfo2(countingStream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkGetImageMemoryRequirements2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetImageMemoryRequirements2KHR = OP_vkGetImageMemoryRequirements2KHR;
+ stream->write(&opcode_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1126;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1126, 1);
+ stream->write((uint64_t*)&cgen_var_1126, 1 * 8);
+ marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetBufferMemoryRequirements2KHR(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBufferMemoryRequirementsInfo2* local_pInfo;
+ local_device = device;
+ local_pInfo = nullptr;
+ if (pInfo)
+ {
+ local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
+ deepcopy_VkBufferMemoryRequirementsInfo2(pool, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1127;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1127, 1);
+ countingStream->write((uint64_t*)&cgen_var_1127, 1 * 8);
+ marshal_VkBufferMemoryRequirementsInfo2(countingStream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkGetBufferMemoryRequirements2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetBufferMemoryRequirements2KHR = OP_vkGetBufferMemoryRequirements2KHR;
+ stream->write(&opcode_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1128;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1128, 1);
+ stream->write((uint64_t*)&cgen_var_1128, 1 * 8);
+ marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
+}
+
+void VkEncoder::vkGetImageSparseMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImageSparseMemoryRequirementsInfo2* local_pInfo;
+ local_device = device;
+ local_pInfo = nullptr;
+ if (pInfo)
+ {
+ local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
+ deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1129;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1129, 1);
+ countingStream->write((uint64_t*)&cgen_var_1129, 1 * 8);
+ marshal_VkImageSparseMemoryRequirementsInfo2(countingStream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1130 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ countingStream->putBe64(cgen_var_1130);
+ if (pSparseMemoryRequirementCount)
+ {
+ countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1131 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ countingStream->putBe64(cgen_var_1131);
+ if (pSparseMemoryRequirements)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ marshal_VkSparseImageMemoryRequirements2(countingStream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetImageSparseMemoryRequirements2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetImageSparseMemoryRequirements2KHR = OP_vkGetImageSparseMemoryRequirements2KHR;
+ stream->write(&opcode_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1132;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1132, 1);
+ stream->write((uint64_t*)&cgen_var_1132, 1 * 8);
+ marshal_VkImageSparseMemoryRequirementsInfo2(stream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1133 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ stream->putBe64(cgen_var_1133);
+ if (pSparseMemoryRequirementCount)
+ {
+ stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1134 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ stream->putBe64(cgen_var_1134);
+ if (pSparseMemoryRequirements)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ marshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pSparseMemoryRequirementCount;
+ check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirementCount)
+ {
+ if (!(check_pSparseMemoryRequirementCount))
+ {
+ fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkSparseImageMemoryRequirements2* check_pSparseMemoryRequirements;
+ check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirements)
+ {
+ if (!(check_pSparseMemoryRequirements))
+ {
+ fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
+ {
+ unmarshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSamplerYcbcrConversionCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
+ deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1137;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1137, 1);
+ countingStream->write((uint64_t*)&cgen_var_1137, 1 * 8);
+ marshal_VkSamplerYcbcrConversionCreateInfo(countingStream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1138 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1138);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1139;
+ countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1139, 1);
+ countingStream->write((uint64_t*)&cgen_var_1139, 8);
+ }
+ uint32_t packetSize_vkCreateSamplerYcbcrConversionKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateSamplerYcbcrConversionKHR = OP_vkCreateSamplerYcbcrConversionKHR;
+ stream->write(&opcode_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1140;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1140, 1);
+ stream->write((uint64_t*)&cgen_var_1140, 1 * 8);
+ marshal_VkSamplerYcbcrConversionCreateInfo(stream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1141 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1141);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1142;
+ stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1142, 1);
+ stream->write((uint64_t*)&cgen_var_1142, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_1143;
+ stream->read((uint64_t*)&cgen_var_1143, 8);
+ stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_1143, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+ VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateSamplerYcbcrConversionKHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
+}
+
+void VkEncoder::vkDestroySamplerYcbcrConversionKHR(
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSamplerYcbcrConversion local_ycbcrConversion;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_ycbcrConversion = ycbcrConversion;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1144;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1144, 1);
+ countingStream->write((uint64_t*)&cgen_var_1144, 1 * 8);
+ uint64_t cgen_var_1145;
+ countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1145, 1);
+ countingStream->write((uint64_t*)&cgen_var_1145, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1146 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1146);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroySamplerYcbcrConversionKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroySamplerYcbcrConversionKHR = OP_vkDestroySamplerYcbcrConversionKHR;
+ stream->write(&opcode_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1147;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1147, 1);
+ stream->write((uint64_t*)&cgen_var_1147, 1 * 8);
+ uint64_t cgen_var_1148;
+ stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1148, 1);
+ stream->write((uint64_t*)&cgen_var_1148, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1149 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1149);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+}
+
+#endif
+#ifdef VK_KHR_bind_memory2
+VkResult VkEncoder::vkBindBufferMemory2KHR(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_bindInfoCount;
+ VkBindBufferMemoryInfo* local_pBindInfos;
+ local_device = device;
+ local_bindInfoCount = bindInfoCount;
+ local_pBindInfos = nullptr;
+ if (pBindInfos)
+ {
+ local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ deepcopy_VkBindBufferMemoryInfo(pool, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1150;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1150, 1);
+ countingStream->write((uint64_t*)&cgen_var_1150, 1 * 8);
+ countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindBufferMemoryInfo(countingStream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ }
+ }
+ uint32_t packetSize_vkBindBufferMemory2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkBindBufferMemory2KHR = OP_vkBindBufferMemory2KHR;
+ stream->write(&opcode_vkBindBufferMemory2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkBindBufferMemory2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1151;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1151, 1);
+ stream->write((uint64_t*)&cgen_var_1151, 1 * 8);
+ stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ }
+ VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkBindBufferMemory2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkBindBufferMemory2KHR_VkResult_return;
+}
+
+VkResult VkEncoder::vkBindImageMemory2KHR(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_bindInfoCount;
+ VkBindImageMemoryInfo* local_pBindInfos;
+ local_device = device;
+ local_bindInfoCount = bindInfoCount;
+ local_pBindInfos = nullptr;
+ if (pBindInfos)
+ {
+ local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ deepcopy_VkBindImageMemoryInfo(pool, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1152;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1152, 1);
+ countingStream->write((uint64_t*)&cgen_var_1152, 1 * 8);
+ countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindImageMemoryInfo(countingStream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ }
+ }
+ uint32_t packetSize_vkBindImageMemory2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkBindImageMemory2KHR = OP_vkBindImageMemory2KHR;
+ stream->write(&opcode_vkBindImageMemory2KHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkBindImageMemory2KHR, sizeof(uint32_t));
+ uint64_t cgen_var_1153;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1153, 1);
+ stream->write((uint64_t*)&cgen_var_1153, 1 * 8);
+ stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
+ {
+ marshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ }
+ VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
+ stream->read(&vkBindImageMemory2KHR_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkBindImageMemory2KHR_VkResult_return;
+}
+
+#endif
+#ifdef VK_KHR_maintenance3
+void VkEncoder::vkGetDescriptorSetLayoutSupportKHR(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDescriptorSetLayoutCreateInfo* local_pCreateInfo;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(pool, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1154;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1154, 1);
+ countingStream->write((uint64_t*)&cgen_var_1154, 1 * 8);
+ marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ marshal_VkDescriptorSetLayoutSupport(countingStream, (VkDescriptorSetLayoutSupport*)(pSupport));
+ }
+ uint32_t packetSize_vkGetDescriptorSetLayoutSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetDescriptorSetLayoutSupportKHR = OP_vkGetDescriptorSetLayoutSupportKHR;
+ stream->write(&opcode_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1155;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1155, 1);
+ stream->write((uint64_t*)&cgen_var_1155, 1 * 8);
+ marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
+ unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
+}
+
+#endif
+#ifdef VK_KHR_draw_indirect_count
+void VkEncoder::vkCmdDrawIndirectCountKHR(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ VkBuffer local_countBuffer;
+ VkDeviceSize local_countBufferOffset;
+ uint32_t local_maxDrawCount;
+ uint32_t local_stride;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_countBuffer = countBuffer;
+ local_countBufferOffset = countBufferOffset;
+ local_maxDrawCount = maxDrawCount;
+ local_stride = stride;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1156;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1156, 1);
+ countingStream->write((uint64_t*)&cgen_var_1156, 1 * 8);
+ uint64_t cgen_var_1157;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1157, 1);
+ countingStream->write((uint64_t*)&cgen_var_1157, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_1158;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1158, 1);
+ countingStream->write((uint64_t*)&cgen_var_1158, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDrawIndirectCountKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDrawIndirectCountKHR = OP_vkCmdDrawIndirectCountKHR;
+ stream->write(&opcode_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1159;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1159, 1);
+ stream->write((uint64_t*)&cgen_var_1159, 1 * 8);
+ uint64_t cgen_var_1160;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1160, 1);
+ stream->write((uint64_t*)&cgen_var_1160, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_1161;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1161, 1);
+ stream->write((uint64_t*)&cgen_var_1161, 1 * 8);
+ stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndexedIndirectCountKHR(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ VkBuffer local_countBuffer;
+ VkDeviceSize local_countBufferOffset;
+ uint32_t local_maxDrawCount;
+ uint32_t local_stride;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_countBuffer = countBuffer;
+ local_countBufferOffset = countBufferOffset;
+ local_maxDrawCount = maxDrawCount;
+ local_stride = stride;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1162;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1162, 1);
+ countingStream->write((uint64_t*)&cgen_var_1162, 1 * 8);
+ uint64_t cgen_var_1163;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1163, 1);
+ countingStream->write((uint64_t*)&cgen_var_1163, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_1164;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1164, 1);
+ countingStream->write((uint64_t*)&cgen_var_1164, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDrawIndexedIndirectCountKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDrawIndexedIndirectCountKHR = OP_vkCmdDrawIndexedIndirectCountKHR;
+ stream->write(&opcode_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
+ uint64_t cgen_var_1165;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1165, 1);
+ stream->write((uint64_t*)&cgen_var_1165, 1 * 8);
+ uint64_t cgen_var_1166;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1166, 1);
+ stream->write((uint64_t*)&cgen_var_1166, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_1167;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1167, 1);
+ stream->write((uint64_t*)&cgen_var_1167, 1 * 8);
+ stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(
+ VkDevice device,
+ VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkFormat local_format;
+ VkImageUsageFlags local_imageUsage;
+ local_device = device;
+ local_format = format;
+ local_imageUsage = imageUsage;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1168;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1168, 1);
+ countingStream->write((uint64_t*)&cgen_var_1168, 1 * 8);
+ countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ countingStream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
+ countingStream->write((int*)grallocUsage, sizeof(int));
+ }
+ uint32_t packetSize_vkGetSwapchainGrallocUsageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetSwapchainGrallocUsageANDROID = OP_vkGetSwapchainGrallocUsageANDROID;
+ stream->write(&opcode_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
+ uint64_t cgen_var_1169;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1169, 1);
+ stream->write((uint64_t*)&cgen_var_1169, 1 * 8);
+ stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ stream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
+ stream->write((int*)grallocUsage, sizeof(int));
+ stream->read((int*)grallocUsage, sizeof(int));
+ VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
+ stream->read(&vkGetSwapchainGrallocUsageANDROID_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
+}
+
+VkResult VkEncoder::vkAcquireImageANDROID(
+ VkDevice device,
+ VkImage image,
+ int nativeFenceFd,
+ VkSemaphore semaphore,
+ VkFence fence)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImage local_image;
+ int local_nativeFenceFd;
+ VkSemaphore local_semaphore;
+ VkFence local_fence;
+ local_device = device;
+ local_image = image;
+ local_nativeFenceFd = nativeFenceFd;
+ local_semaphore = semaphore;
+ local_fence = fence;
+ goldfish_unwrap_vkAcquireImageANDROID_nativeFenceFd(nativeFenceFd, &local_nativeFenceFd);
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1170;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1170, 1);
+ countingStream->write((uint64_t*)&cgen_var_1170, 1 * 8);
+ uint64_t cgen_var_1171;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1171, 1);
+ countingStream->write((uint64_t*)&cgen_var_1171, 1 * 8);
+ countingStream->write((int*)&local_nativeFenceFd, sizeof(int));
+ uint64_t cgen_var_1172;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1172, 1);
+ countingStream->write((uint64_t*)&cgen_var_1172, 1 * 8);
+ uint64_t cgen_var_1173;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1173, 1);
+ countingStream->write((uint64_t*)&cgen_var_1173, 1 * 8);
+ }
+ uint32_t packetSize_vkAcquireImageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkAcquireImageANDROID = OP_vkAcquireImageANDROID;
+ stream->write(&opcode_vkAcquireImageANDROID, sizeof(uint32_t));
+ stream->write(&packetSize_vkAcquireImageANDROID, sizeof(uint32_t));
+ uint64_t cgen_var_1174;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1174, 1);
+ stream->write((uint64_t*)&cgen_var_1174, 1 * 8);
+ uint64_t cgen_var_1175;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1175, 1);
+ stream->write((uint64_t*)&cgen_var_1175, 1 * 8);
+ stream->write((int*)&local_nativeFenceFd, sizeof(int));
+ uint64_t cgen_var_1176;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1176, 1);
+ stream->write((uint64_t*)&cgen_var_1176, 1 * 8);
+ uint64_t cgen_var_1177;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1177, 1);
+ stream->write((uint64_t*)&cgen_var_1177, 1 * 8);
+ VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
+ stream->read(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkAcquireImageANDROID_VkResult_return;
+}
+
+VkResult VkEncoder::vkQueueSignalReleaseImageANDROID(
+ VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image,
+ int* pNativeFenceFd)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ uint32_t local_waitSemaphoreCount;
+ VkSemaphore* local_pWaitSemaphores;
+ VkImage local_image;
+ local_queue = queue;
+ local_waitSemaphoreCount = waitSemaphoreCount;
+ local_pWaitSemaphores = nullptr;
+ if (pWaitSemaphores)
+ {
+ local_pWaitSemaphores = (VkSemaphore*)pool->dupArray(pWaitSemaphores, sizeof(const VkSemaphore));
+ }
+ local_image = image;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1178;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1178, 1);
+ countingStream->write((uint64_t*)&cgen_var_1178, 1 * 8);
+ countingStream->write((uint32_t*)&local_waitSemaphoreCount, sizeof(uint32_t));
+ uint64_t cgen_var_1179;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, &cgen_var_1179, 1);
+ countingStream->write((uint64_t*)&cgen_var_1179, 8);
+ uint64_t cgen_var_1180;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1180, 1);
+ countingStream->write((uint64_t*)&cgen_var_1180, 1 * 8);
+ countingStream->write((int*)pNativeFenceFd, sizeof(int));
+ }
+ uint32_t packetSize_vkQueueSignalReleaseImageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueueSignalReleaseImageANDROID = OP_vkQueueSignalReleaseImageANDROID;
+ stream->write(&opcode_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
+ uint64_t cgen_var_1181;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1181, 1);
+ stream->write((uint64_t*)&cgen_var_1181, 1 * 8);
+ stream->write((uint32_t*)&local_waitSemaphoreCount, sizeof(uint32_t));
+ uint64_t cgen_var_1182;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, &cgen_var_1182, 1);
+ stream->write((uint64_t*)&cgen_var_1182, 8);
+ uint64_t cgen_var_1183;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1183, 1);
+ stream->write((uint64_t*)&cgen_var_1183, 1 * 8);
+ stream->write((int*)pNativeFenceFd, sizeof(int));
+ stream->read((int*)pNativeFenceFd, sizeof(int));
+ VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
+ stream->read(&vkQueueSignalReleaseImageANDROID_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkQueueSignalReleaseImageANDROID_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_debug_report
+VkResult VkEncoder::vkCreateDebugReportCallbackEXT(
+ VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkDebugReportCallbackCreateInfoEXT* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDebugReportCallbackCreateInfoEXT*)pool->alloc(sizeof(const VkDebugReportCallbackCreateInfoEXT));
+ deepcopy_VkDebugReportCallbackCreateInfoEXT(pool, pCreateInfo, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1184;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1184, 1);
+ countingStream->write((uint64_t*)&cgen_var_1184, 1 * 8);
+ marshal_VkDebugReportCallbackCreateInfoEXT(countingStream, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1185 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1185);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1186;
+ countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1186, 1);
+ countingStream->write((uint64_t*)&cgen_var_1186, 8);
+ }
+ uint32_t packetSize_vkCreateDebugReportCallbackEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDebugReportCallbackEXT = OP_vkCreateDebugReportCallbackEXT;
+ stream->write(&opcode_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1187;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1187, 1);
+ stream->write((uint64_t*)&cgen_var_1187, 1 * 8);
+ marshal_VkDebugReportCallbackCreateInfoEXT(stream, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1188 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1188);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1189;
+ stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1189, 1);
+ stream->write((uint64_t*)&cgen_var_1189, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_1190;
+ stream->read((uint64_t*)&cgen_var_1190, 8);
+ stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_1190, (VkDebugReportCallbackEXT*)pCallback, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDebugReportCallbackEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateDebugReportCallbackEXT_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDebugReportCallbackEXT(
+ VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkDebugReportCallbackEXT local_callback;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_callback = callback;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1191;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1191, 1);
+ countingStream->write((uint64_t*)&cgen_var_1191, 1 * 8);
+ uint64_t cgen_var_1192;
+ countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1192, 1);
+ countingStream->write((uint64_t*)&cgen_var_1192, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1193 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1193);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyDebugReportCallbackEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyDebugReportCallbackEXT = OP_vkDestroyDebugReportCallbackEXT;
+ stream->write(&opcode_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1194;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1194, 1);
+ stream->write((uint64_t*)&cgen_var_1194, 1 * 8);
+ uint64_t cgen_var_1195;
+ stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1195, 1);
+ stream->write((uint64_t*)&cgen_var_1195, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1196 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1196);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkDebugReportCallbackEXT((VkDebugReportCallbackEXT*)&callback);
+}
+
+void VkEncoder::vkDebugReportMessageEXT(
+ VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char* pLayerPrefix,
+ const char* pMessage)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkDebugReportFlagsEXT local_flags;
+ VkDebugReportObjectTypeEXT local_objectType;
+ uint64_t local_object;
+ size_t local_location;
+ int32_t local_messageCode;
+ char* local_pLayerPrefix;
+ char* local_pMessage;
+ local_instance = instance;
+ local_flags = flags;
+ local_objectType = objectType;
+ local_object = object;
+ local_location = location;
+ local_messageCode = messageCode;
+ local_pLayerPrefix = nullptr;
+ if (pLayerPrefix)
+ {
+ local_pLayerPrefix = pool->strDup(pLayerPrefix);
+ }
+ local_pMessage = nullptr;
+ if (pMessage)
+ {
+ local_pMessage = pool->strDup(pMessage);
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1197;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1197, 1);
+ countingStream->write((uint64_t*)&cgen_var_1197, 1 * 8);
+ countingStream->write((VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
+ countingStream->write((VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
+ countingStream->write((uint64_t*)&local_object, sizeof(uint64_t));
+ uint64_t cgen_var_1198 = (uint64_t)local_location;
+ countingStream->putBe64(cgen_var_1198);
+ countingStream->write((int32_t*)&local_messageCode, sizeof(int32_t));
+ countingStream->putString(local_pLayerPrefix);
+ countingStream->putString(local_pMessage);
+ }
+ uint32_t packetSize_vkDebugReportMessageEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDebugReportMessageEXT = OP_vkDebugReportMessageEXT;
+ stream->write(&opcode_vkDebugReportMessageEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkDebugReportMessageEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1199;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1199, 1);
+ stream->write((uint64_t*)&cgen_var_1199, 1 * 8);
+ stream->write((VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
+ stream->write((VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
+ stream->write((uint64_t*)&local_object, sizeof(uint64_t));
+ uint64_t cgen_var_1200 = (uint64_t)local_location;
+ stream->putBe64(cgen_var_1200);
+ stream->write((int32_t*)&local_messageCode, sizeof(int32_t));
+ stream->putString(local_pLayerPrefix);
+ stream->putString(local_pMessage);
+}
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDebugMarkerObjectTagInfoEXT* local_pTagInfo;
+ local_device = device;
+ local_pTagInfo = nullptr;
+ if (pTagInfo)
+ {
+ local_pTagInfo = (VkDebugMarkerObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectTagInfoEXT));
+ deepcopy_VkDebugMarkerObjectTagInfoEXT(pool, pTagInfo, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1201;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1201, 1);
+ countingStream->write((uint64_t*)&cgen_var_1201, 1 * 8);
+ marshal_VkDebugMarkerObjectTagInfoEXT(countingStream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+ }
+ uint32_t packetSize_vkDebugMarkerSetObjectTagEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDebugMarkerSetObjectTagEXT = OP_vkDebugMarkerSetObjectTagEXT;
+ stream->write(&opcode_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1202;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1202, 1);
+ stream->write((uint64_t*)&cgen_var_1202, 1 * 8);
+ marshal_VkDebugMarkerObjectTagInfoEXT(stream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+ VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkDebugMarkerSetObjectTagEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDebugMarkerObjectNameInfoEXT* local_pNameInfo;
+ local_device = device;
+ local_pNameInfo = nullptr;
+ if (pNameInfo)
+ {
+ local_pNameInfo = (VkDebugMarkerObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectNameInfoEXT));
+ deepcopy_VkDebugMarkerObjectNameInfoEXT(pool, pNameInfo, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1203;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1203, 1);
+ countingStream->write((uint64_t*)&cgen_var_1203, 1 * 8);
+ marshal_VkDebugMarkerObjectNameInfoEXT(countingStream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+ }
+ uint32_t packetSize_vkDebugMarkerSetObjectNameEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDebugMarkerSetObjectNameEXT = OP_vkDebugMarkerSetObjectNameEXT;
+ stream->write(&opcode_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1204;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1204, 1);
+ stream->write((uint64_t*)&cgen_var_1204, 1 * 8);
+ marshal_VkDebugMarkerObjectNameInfoEXT(stream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+ VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkDebugMarkerSetObjectNameEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
+
+void VkEncoder::vkCmdDebugMarkerBeginEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkDebugMarkerMarkerInfoEXT* local_pMarkerInfo;
+ local_commandBuffer = commandBuffer;
+ local_pMarkerInfo = nullptr;
+ if (pMarkerInfo)
+ {
+ local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
+ deepcopy_VkDebugMarkerMarkerInfoEXT(pool, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1205;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1205, 1);
+ countingStream->write((uint64_t*)&cgen_var_1205, 1 * 8);
+ marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ }
+ uint32_t packetSize_vkCmdDebugMarkerBeginEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDebugMarkerBeginEXT = OP_vkCmdDebugMarkerBeginEXT;
+ stream->write(&opcode_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1206;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1206, 1);
+ stream->write((uint64_t*)&cgen_var_1206, 1 * 8);
+ marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+}
+
+void VkEncoder::vkCmdDebugMarkerEndEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ local_commandBuffer = commandBuffer;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1207;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1207, 1);
+ countingStream->write((uint64_t*)&cgen_var_1207, 1 * 8);
+ }
+ uint32_t packetSize_vkCmdDebugMarkerEndEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDebugMarkerEndEXT = OP_vkCmdDebugMarkerEndEXT;
+ stream->write(&opcode_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1208;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1208, 1);
+ stream->write((uint64_t*)&cgen_var_1208, 1 * 8);
+}
+
+void VkEncoder::vkCmdDebugMarkerInsertEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkDebugMarkerMarkerInfoEXT* local_pMarkerInfo;
+ local_commandBuffer = commandBuffer;
+ local_pMarkerInfo = nullptr;
+ if (pMarkerInfo)
+ {
+ local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
+ deepcopy_VkDebugMarkerMarkerInfoEXT(pool, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1209;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1209, 1);
+ countingStream->write((uint64_t*)&cgen_var_1209, 1 * 8);
+ marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ }
+ uint32_t packetSize_vkCmdDebugMarkerInsertEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDebugMarkerInsertEXT = OP_vkCmdDebugMarkerInsertEXT;
+ stream->write(&opcode_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1210;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1210, 1);
+ stream->write((uint64_t*)&cgen_var_1210, 1 * 8);
+ marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+}
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+void VkEncoder::vkCmdDrawIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ VkBuffer local_countBuffer;
+ VkDeviceSize local_countBufferOffset;
+ uint32_t local_maxDrawCount;
+ uint32_t local_stride;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_countBuffer = countBuffer;
+ local_countBufferOffset = countBufferOffset;
+ local_maxDrawCount = maxDrawCount;
+ local_stride = stride;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1211;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1211, 1);
+ countingStream->write((uint64_t*)&cgen_var_1211, 1 * 8);
+ uint64_t cgen_var_1212;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1212, 1);
+ countingStream->write((uint64_t*)&cgen_var_1212, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_1213;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1213, 1);
+ countingStream->write((uint64_t*)&cgen_var_1213, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDrawIndirectCountAMD = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDrawIndirectCountAMD = OP_vkCmdDrawIndirectCountAMD;
+ stream->write(&opcode_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
+ uint64_t cgen_var_1214;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1214, 1);
+ stream->write((uint64_t*)&cgen_var_1214, 1 * 8);
+ uint64_t cgen_var_1215;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1215, 1);
+ stream->write((uint64_t*)&cgen_var_1215, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_1216;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1216, 1);
+ stream->write((uint64_t*)&cgen_var_1216, 1 * 8);
+ stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+void VkEncoder::vkCmdDrawIndexedIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ VkBuffer local_countBuffer;
+ VkDeviceSize local_countBufferOffset;
+ uint32_t local_maxDrawCount;
+ uint32_t local_stride;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_countBuffer = countBuffer;
+ local_countBufferOffset = countBufferOffset;
+ local_maxDrawCount = maxDrawCount;
+ local_stride = stride;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1217;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1217, 1);
+ countingStream->write((uint64_t*)&cgen_var_1217, 1 * 8);
+ uint64_t cgen_var_1218;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1218, 1);
+ countingStream->write((uint64_t*)&cgen_var_1218, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_1219;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1219, 1);
+ countingStream->write((uint64_t*)&cgen_var_1219, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDrawIndexedIndirectCountAMD = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDrawIndexedIndirectCountAMD = OP_vkCmdDrawIndexedIndirectCountAMD;
+ stream->write(&opcode_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
+ uint64_t cgen_var_1220;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1220, 1);
+ stream->write((uint64_t*)&cgen_var_1220, 1 * 8);
+ uint64_t cgen_var_1221;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1221, 1);
+ stream->write((uint64_t*)&cgen_var_1221, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_1222;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1222, 1);
+ stream->write((uint64_t*)&cgen_var_1222, 1 * 8);
+ stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+VkResult VkEncoder::vkGetShaderInfoAMD(
+ VkDevice device,
+ VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType,
+ size_t* pInfoSize,
+ void* pInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkPipeline local_pipeline;
+ VkShaderStageFlagBits local_shaderStage;
+ VkShaderInfoTypeAMD local_infoType;
+ local_device = device;
+ local_pipeline = pipeline;
+ local_shaderStage = shaderStage;
+ local_infoType = infoType;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1223;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1223, 1);
+ countingStream->write((uint64_t*)&cgen_var_1223, 1 * 8);
+ uint64_t cgen_var_1224;
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1224, 1);
+ countingStream->write((uint64_t*)&cgen_var_1224, 1 * 8);
+ countingStream->write((VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
+ countingStream->write((VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1225 = (uint64_t)(uintptr_t)pInfoSize;
+ countingStream->putBe64(cgen_var_1225);
+ if (pInfoSize)
+ {
+ uint64_t cgen_var_1226 = (uint64_t)(*pInfoSize);
+ countingStream->putBe64(cgen_var_1226);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1227 = (uint64_t)(uintptr_t)pInfo;
+ countingStream->putBe64(cgen_var_1227);
+ if (pInfo)
+ {
+ countingStream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
+ }
+ }
+ uint32_t packetSize_vkGetShaderInfoAMD = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetShaderInfoAMD = OP_vkGetShaderInfoAMD;
+ stream->write(&opcode_vkGetShaderInfoAMD, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetShaderInfoAMD, sizeof(uint32_t));
+ uint64_t cgen_var_1228;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1228, 1);
+ stream->write((uint64_t*)&cgen_var_1228, 1 * 8);
+ uint64_t cgen_var_1229;
+ stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1229, 1);
+ stream->write((uint64_t*)&cgen_var_1229, 1 * 8);
+ stream->write((VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
+ stream->write((VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1230 = (uint64_t)(uintptr_t)pInfoSize;
+ stream->putBe64(cgen_var_1230);
+ if (pInfoSize)
+ {
+ uint64_t cgen_var_1231 = (uint64_t)(*pInfoSize);
+ stream->putBe64(cgen_var_1231);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1232 = (uint64_t)(uintptr_t)pInfo;
+ stream->putBe64(cgen_var_1232);
+ if (pInfo)
+ {
+ stream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
+ }
+ // WARNING PTR CHECK
+ size_t* check_pInfoSize;
+ check_pInfoSize = (size_t*)(uintptr_t)stream->getBe64();
+ if (pInfoSize)
+ {
+ if (!(check_pInfoSize))
+ {
+ fprintf(stderr, "fatal: pInfoSize inconsistent between guest and host\n");
+ }
+ (*pInfoSize) = (size_t)stream->getBe64();
+ }
+ // WARNING PTR CHECK
+ void* check_pInfo;
+ check_pInfo = (void*)(uintptr_t)stream->getBe64();
+ if (pInfo)
+ {
+ if (!(check_pInfo))
+ {
+ fprintf(stderr, "fatal: pInfo inconsistent between guest and host\n");
+ }
+ stream->read((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
+ }
+ VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+ stream->read(&vkGetShaderInfoAMD_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetShaderInfoAMD_VkResult_return;
+}
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkFormat local_format;
+ VkImageType local_type;
+ VkImageTiling local_tiling;
+ VkImageUsageFlags local_usage;
+ VkImageCreateFlags local_flags;
+ VkExternalMemoryHandleTypeFlagsNV local_externalHandleType;
+ local_physicalDevice = physicalDevice;
+ local_format = format;
+ local_type = type;
+ local_tiling = tiling;
+ local_usage = usage;
+ local_flags = flags;
+ local_externalHandleType = externalHandleType;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1236;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1236, 1);
+ countingStream->write((uint64_t*)&cgen_var_1236, 1 * 8);
+ countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
+ countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+ countingStream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+ countingStream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
+ countingStream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ marshal_VkExternalImageFormatPropertiesNV(countingStream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+ stream->write(&opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
+ uint64_t cgen_var_1237;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1237, 1);
+ stream->write((uint64_t*)&cgen_var_1237, 1 * 8);
+ stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+ stream->write((VkImageType*)&local_type, sizeof(VkImageType));
+ stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
+ stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
+ stream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
+ stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ marshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
+ unmarshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
+ VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
+}
+
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+VkResult VkEncoder::vkGetMemoryWin32HandleNV(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDeviceMemory local_memory;
+ VkExternalMemoryHandleTypeFlagsNV local_handleType;
+ local_device = device;
+ local_memory = memory;
+ local_handleType = handleType;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1238;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1238, 1);
+ countingStream->write((uint64_t*)&cgen_var_1238, 1 * 8);
+ uint64_t cgen_var_1239;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1239, 1);
+ countingStream->write((uint64_t*)&cgen_var_1239, 1 * 8);
+ countingStream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
+ }
+ uint32_t packetSize_vkGetMemoryWin32HandleNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetMemoryWin32HandleNV = OP_vkGetMemoryWin32HandleNV;
+ stream->write(&opcode_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
+ uint64_t cgen_var_1240;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1240, 1);
+ stream->write((uint64_t*)&cgen_var_1240, 1 * 8);
+ uint64_t cgen_var_1241;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1241, 1);
+ stream->write((uint64_t*)&cgen_var_1241, 1 * 8);
+ stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ stream->write((HANDLE*)pHandle, sizeof(HANDLE));
+ stream->read((HANDLE*)pHandle, sizeof(HANDLE));
+ VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+ stream->read(&vkGetMemoryWin32HandleNV_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetMemoryWin32HandleNV_VkResult_return;
+}
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+VkResult VkEncoder::vkCreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkViSurfaceCreateInfoNN* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkViSurfaceCreateInfoNN*)pool->alloc(sizeof(const VkViSurfaceCreateInfoNN));
+ deepcopy_VkViSurfaceCreateInfoNN(pool, pCreateInfo, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1242;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1242, 1);
+ countingStream->write((uint64_t*)&cgen_var_1242, 1 * 8);
+ marshal_VkViSurfaceCreateInfoNN(countingStream, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1243 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1243);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1244;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1244, 1);
+ countingStream->write((uint64_t*)&cgen_var_1244, 8);
+ }
+ uint32_t packetSize_vkCreateViSurfaceNN = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateViSurfaceNN = OP_vkCreateViSurfaceNN;
+ stream->write(&opcode_vkCreateViSurfaceNN, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateViSurfaceNN, sizeof(uint32_t));
+ uint64_t cgen_var_1245;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1245, 1);
+ stream->write((uint64_t*)&cgen_var_1245, 1 * 8);
+ marshal_VkViSurfaceCreateInfoNN(stream, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1246 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1246);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1247;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1247, 1);
+ stream->write((uint64_t*)&cgen_var_1247, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_1248;
+ stream->read((uint64_t*)&cgen_var_1248, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1248, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateViSurfaceNN_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateViSurfaceNN_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void VkEncoder::vkCmdBeginConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkConditionalRenderingBeginInfoEXT* local_pConditionalRenderingBegin;
+ local_commandBuffer = commandBuffer;
+ local_pConditionalRenderingBegin = nullptr;
+ if (pConditionalRenderingBegin)
+ {
+ local_pConditionalRenderingBegin = (VkConditionalRenderingBeginInfoEXT*)pool->alloc(sizeof(const VkConditionalRenderingBeginInfoEXT));
+ deepcopy_VkConditionalRenderingBeginInfoEXT(pool, pConditionalRenderingBegin, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1249;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1249, 1);
+ countingStream->write((uint64_t*)&cgen_var_1249, 1 * 8);
+ marshal_VkConditionalRenderingBeginInfoEXT(countingStream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+ }
+ uint32_t packetSize_vkCmdBeginConditionalRenderingEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBeginConditionalRenderingEXT = OP_vkCmdBeginConditionalRenderingEXT;
+ stream->write(&opcode_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1250;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1250, 1);
+ stream->write((uint64_t*)&cgen_var_1250, 1 * 8);
+ marshal_VkConditionalRenderingBeginInfoEXT(stream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+}
+
+void VkEncoder::vkCmdEndConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ local_commandBuffer = commandBuffer;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1251;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1251, 1);
+ countingStream->write((uint64_t*)&cgen_var_1251, 1 * 8);
+ }
+ uint32_t packetSize_vkCmdEndConditionalRenderingEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdEndConditionalRenderingEXT = OP_vkCmdEndConditionalRenderingEXT;
+ stream->write(&opcode_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1252;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1252, 1);
+ stream->write((uint64_t*)&cgen_var_1252, 1 * 8);
+}
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void VkEncoder::vkCmdProcessCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkCmdProcessCommandsInfoNVX* local_pProcessCommandsInfo;
+ local_commandBuffer = commandBuffer;
+ local_pProcessCommandsInfo = nullptr;
+ if (pProcessCommandsInfo)
+ {
+ local_pProcessCommandsInfo = (VkCmdProcessCommandsInfoNVX*)pool->alloc(sizeof(const VkCmdProcessCommandsInfoNVX));
+ deepcopy_VkCmdProcessCommandsInfoNVX(pool, pProcessCommandsInfo, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1253;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1253, 1);
+ countingStream->write((uint64_t*)&cgen_var_1253, 1 * 8);
+ marshal_VkCmdProcessCommandsInfoNVX(countingStream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
+ }
+ uint32_t packetSize_vkCmdProcessCommandsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdProcessCommandsNVX = OP_vkCmdProcessCommandsNVX;
+ stream->write(&opcode_vkCmdProcessCommandsNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdProcessCommandsNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1254;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1254, 1);
+ stream->write((uint64_t*)&cgen_var_1254, 1 * 8);
+ marshal_VkCmdProcessCommandsInfoNVX(stream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
+}
+
+void VkEncoder::vkCmdReserveSpaceForCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkCmdReserveSpaceForCommandsInfoNVX* local_pReserveSpaceInfo;
+ local_commandBuffer = commandBuffer;
+ local_pReserveSpaceInfo = nullptr;
+ if (pReserveSpaceInfo)
+ {
+ local_pReserveSpaceInfo = (VkCmdReserveSpaceForCommandsInfoNVX*)pool->alloc(sizeof(const VkCmdReserveSpaceForCommandsInfoNVX));
+ deepcopy_VkCmdReserveSpaceForCommandsInfoNVX(pool, pReserveSpaceInfo, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1255;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1255, 1);
+ countingStream->write((uint64_t*)&cgen_var_1255, 1 * 8);
+ marshal_VkCmdReserveSpaceForCommandsInfoNVX(countingStream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
+ }
+ uint32_t packetSize_vkCmdReserveSpaceForCommandsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdReserveSpaceForCommandsNVX = OP_vkCmdReserveSpaceForCommandsNVX;
+ stream->write(&opcode_vkCmdReserveSpaceForCommandsNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdReserveSpaceForCommandsNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1256;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1256, 1);
+ stream->write((uint64_t*)&cgen_var_1256, 1 * 8);
+ marshal_VkCmdReserveSpaceForCommandsInfoNVX(stream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
+}
+
+VkResult VkEncoder::vkCreateIndirectCommandsLayoutNVX(
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkIndirectCommandsLayoutCreateInfoNVX* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkIndirectCommandsLayoutCreateInfoNVX*)pool->alloc(sizeof(const VkIndirectCommandsLayoutCreateInfoNVX));
+ deepcopy_VkIndirectCommandsLayoutCreateInfoNVX(pool, pCreateInfo, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1257;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1257, 1);
+ countingStream->write((uint64_t*)&cgen_var_1257, 1 * 8);
+ marshal_VkIndirectCommandsLayoutCreateInfoNVX(countingStream, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1258 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1258);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1259;
+ countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1259, 1);
+ countingStream->write((uint64_t*)&cgen_var_1259, 8);
+ }
+ uint32_t packetSize_vkCreateIndirectCommandsLayoutNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateIndirectCommandsLayoutNVX = OP_vkCreateIndirectCommandsLayoutNVX;
+ stream->write(&opcode_vkCreateIndirectCommandsLayoutNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateIndirectCommandsLayoutNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1260;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1260, 1);
+ stream->write((uint64_t*)&cgen_var_1260, 1 * 8);
+ marshal_VkIndirectCommandsLayoutCreateInfoNVX(stream, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1261 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1261);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1262;
+ stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1262, 1);
+ stream->write((uint64_t*)&cgen_var_1262, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_1263;
+ stream->read((uint64_t*)&cgen_var_1263, 8);
+ stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_1263, (VkIndirectCommandsLayoutNVX*)pIndirectCommandsLayout, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateIndirectCommandsLayoutNVX_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
+
+void VkEncoder::vkDestroyIndirectCommandsLayoutNVX(
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkIndirectCommandsLayoutNVX local_indirectCommandsLayout;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_indirectCommandsLayout = indirectCommandsLayout;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1264;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1264, 1);
+ countingStream->write((uint64_t*)&cgen_var_1264, 1 * 8);
+ uint64_t cgen_var_1265;
+ countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1265, 1);
+ countingStream->write((uint64_t*)&cgen_var_1265, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1266 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1266);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyIndirectCommandsLayoutNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyIndirectCommandsLayoutNVX = OP_vkDestroyIndirectCommandsLayoutNVX;
+ stream->write(&opcode_vkDestroyIndirectCommandsLayoutNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyIndirectCommandsLayoutNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1267;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1267, 1);
+ stream->write((uint64_t*)&cgen_var_1267, 1 * 8);
+ uint64_t cgen_var_1268;
+ stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1268, 1);
+ stream->write((uint64_t*)&cgen_var_1268, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1269 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1269);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&indirectCommandsLayout);
+}
+
+VkResult VkEncoder::vkCreateObjectTableNVX(
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkObjectTableCreateInfoNVX* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkObjectTableCreateInfoNVX*)pool->alloc(sizeof(const VkObjectTableCreateInfoNVX));
+ deepcopy_VkObjectTableCreateInfoNVX(pool, pCreateInfo, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1270;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1270, 1);
+ countingStream->write((uint64_t*)&cgen_var_1270, 1 * 8);
+ marshal_VkObjectTableCreateInfoNVX(countingStream, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1271 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1271);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1272;
+ countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1272, 1);
+ countingStream->write((uint64_t*)&cgen_var_1272, 8);
+ }
+ uint32_t packetSize_vkCreateObjectTableNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateObjectTableNVX = OP_vkCreateObjectTableNVX;
+ stream->write(&opcode_vkCreateObjectTableNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateObjectTableNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1273;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1273, 1);
+ stream->write((uint64_t*)&cgen_var_1273, 1 * 8);
+ marshal_VkObjectTableCreateInfoNVX(stream, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1274 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1274);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1275;
+ stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1275, 1);
+ stream->write((uint64_t*)&cgen_var_1275, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_1276;
+ stream->read((uint64_t*)&cgen_var_1276, 8);
+ stream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_1276, (VkObjectTableNVX*)pObjectTable, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateObjectTableNVX_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateObjectTableNVX_VkResult_return;
+}
+
+void VkEncoder::vkDestroyObjectTableNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkObjectTableNVX local_objectTable;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_objectTable = objectTable;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1277;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1277, 1);
+ countingStream->write((uint64_t*)&cgen_var_1277, 1 * 8);
+ uint64_t cgen_var_1278;
+ countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1278, 1);
+ countingStream->write((uint64_t*)&cgen_var_1278, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1279 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1279);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyObjectTableNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyObjectTableNVX = OP_vkDestroyObjectTableNVX;
+ stream->write(&opcode_vkDestroyObjectTableNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyObjectTableNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1280;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1280, 1);
+ stream->write((uint64_t*)&cgen_var_1280, 1 * 8);
+ uint64_t cgen_var_1281;
+ stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1281, 1);
+ stream->write((uint64_t*)&cgen_var_1281, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1282 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1282);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&objectTable);
+}
+
+VkResult VkEncoder::vkRegisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkObjectTableNVX local_objectTable;
+ uint32_t local_objectCount;
+ VkObjectTableEntryNVX** local_ppObjectTableEntries;
+ uint32_t* local_pObjectIndices;
+ local_device = device;
+ local_objectTable = objectTable;
+ local_objectCount = objectCount;
+ (void)ppObjectTableEntries;
+ local_pObjectIndices = nullptr;
+ if (pObjectIndices)
+ {
+ local_pObjectIndices = (uint32_t*)pool->dupArray(pObjectIndices, ((objectCount)) * sizeof(const uint32_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1283;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1283, 1);
+ countingStream->write((uint64_t*)&cgen_var_1283, 1 * 8);
+ uint64_t cgen_var_1284;
+ countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1284, 1);
+ countingStream->write((uint64_t*)&cgen_var_1284, 1 * 8);
+ countingStream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
+ (void)local_ppObjectTableEntries;
+ countingStream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkRegisterObjectsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkRegisterObjectsNVX = OP_vkRegisterObjectsNVX;
+ stream->write(&opcode_vkRegisterObjectsNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkRegisterObjectsNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1285;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1285, 1);
+ stream->write((uint64_t*)&cgen_var_1285, 1 * 8);
+ uint64_t cgen_var_1286;
+ stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1286, 1);
+ stream->write((uint64_t*)&cgen_var_1286, 1 * 8);
+ stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
+ (void)local_ppObjectTableEntries;
+ stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
+ VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+ stream->read(&vkRegisterObjectsNVX_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkRegisterObjectsNVX_VkResult_return;
+}
+
+VkResult VkEncoder::vkUnregisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkObjectTableNVX local_objectTable;
+ uint32_t local_objectCount;
+ VkObjectEntryTypeNVX* local_pObjectEntryTypes;
+ uint32_t* local_pObjectIndices;
+ local_device = device;
+ local_objectTable = objectTable;
+ local_objectCount = objectCount;
+ local_pObjectEntryTypes = nullptr;
+ if (pObjectEntryTypes)
+ {
+ local_pObjectEntryTypes = (VkObjectEntryTypeNVX*)pool->dupArray(pObjectEntryTypes, ((objectCount)) * sizeof(const VkObjectEntryTypeNVX));
+ }
+ local_pObjectIndices = nullptr;
+ if (pObjectIndices)
+ {
+ local_pObjectIndices = (uint32_t*)pool->dupArray(pObjectIndices, ((objectCount)) * sizeof(const uint32_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1287;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1287, 1);
+ countingStream->write((uint64_t*)&cgen_var_1287, 1 * 8);
+ uint64_t cgen_var_1288;
+ countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1288, 1);
+ countingStream->write((uint64_t*)&cgen_var_1288, 1 * 8);
+ countingStream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
+ countingStream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
+ countingStream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkUnregisterObjectsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkUnregisterObjectsNVX = OP_vkUnregisterObjectsNVX;
+ stream->write(&opcode_vkUnregisterObjectsNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkUnregisterObjectsNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1289;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1289, 1);
+ stream->write((uint64_t*)&cgen_var_1289, 1 * 8);
+ uint64_t cgen_var_1290;
+ stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1290, 1);
+ stream->write((uint64_t*)&cgen_var_1290, 1 * 8);
+ stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
+ stream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
+ stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
+ VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+ stream->read(&vkUnregisterObjectsNVX_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkUnregisterObjectsNVX_VkResult_return;
+}
+
+void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ local_physicalDevice = physicalDevice;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1291;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1291, 1);
+ countingStream->write((uint64_t*)&cgen_var_1291, 1 * 8);
+ marshal_VkDeviceGeneratedCommandsFeaturesNVX(countingStream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
+ marshal_VkDeviceGeneratedCommandsLimitsNVX(countingStream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = OP_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+ stream->write(&opcode_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, sizeof(uint32_t));
+ uint64_t cgen_var_1292;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1292, 1);
+ stream->write((uint64_t*)&cgen_var_1292, 1 * 8);
+ marshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
+ marshal_VkDeviceGeneratedCommandsLimitsNVX(stream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
+ unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
+ unmarshal_VkDeviceGeneratedCommandsLimitsNVX(stream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
+}
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void VkEncoder::vkCmdSetViewportWScalingNV(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_firstViewport;
+ uint32_t local_viewportCount;
+ VkViewportWScalingNV* local_pViewportWScalings;
+ local_commandBuffer = commandBuffer;
+ local_firstViewport = firstViewport;
+ local_viewportCount = viewportCount;
+ local_pViewportWScalings = nullptr;
+ if (pViewportWScalings)
+ {
+ local_pViewportWScalings = (VkViewportWScalingNV*)pool->alloc(((viewportCount)) * sizeof(const VkViewportWScalingNV));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+ {
+ deepcopy_VkViewportWScalingNV(pool, pViewportWScalings + i, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1293;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1293, 1);
+ countingStream->write((uint64_t*)&cgen_var_1293, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+ {
+ marshal_VkViewportWScalingNV(countingStream, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+ }
+ }
+ uint32_t packetSize_vkCmdSetViewportWScalingNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetViewportWScalingNV = OP_vkCmdSetViewportWScalingNV;
+ stream->write(&opcode_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
+ uint64_t cgen_var_1294;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1294, 1);
+ stream->write((uint64_t*)&cgen_var_1294, 1 * 8);
+ stream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
+ {
+ marshal_VkViewportWScalingNV(stream, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+ }
+}
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+VkResult VkEncoder::vkReleaseDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkDisplayKHR local_display;
+ local_physicalDevice = physicalDevice;
+ local_display = display;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1295;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1295, 1);
+ countingStream->write((uint64_t*)&cgen_var_1295, 1 * 8);
+ uint64_t cgen_var_1296;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1296, 1);
+ countingStream->write((uint64_t*)&cgen_var_1296, 1 * 8);
+ }
+ uint32_t packetSize_vkReleaseDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkReleaseDisplayEXT = OP_vkReleaseDisplayEXT;
+ stream->write(&opcode_vkReleaseDisplayEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkReleaseDisplayEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1297;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1297, 1);
+ stream->write((uint64_t*)&cgen_var_1297, 1 * 8);
+ uint64_t cgen_var_1298;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1298, 1);
+ stream->write((uint64_t*)&cgen_var_1298, 1 * 8);
+ VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkReleaseDisplayEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkReleaseDisplayEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+VkResult VkEncoder::vkAcquireXlibDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkDisplayKHR local_display;
+ local_physicalDevice = physicalDevice;
+ local_display = display;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1299;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1299, 1);
+ countingStream->write((uint64_t*)&cgen_var_1299, 1 * 8);
+ countingStream->write((Display*)dpy, sizeof(Display));
+ uint64_t cgen_var_1300;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1300, 1);
+ countingStream->write((uint64_t*)&cgen_var_1300, 1 * 8);
+ }
+ uint32_t packetSize_vkAcquireXlibDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkAcquireXlibDisplayEXT = OP_vkAcquireXlibDisplayEXT;
+ stream->write(&opcode_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1301;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1301, 1);
+ stream->write((uint64_t*)&cgen_var_1301, 1 * 8);
+ stream->write((Display*)dpy, sizeof(Display));
+ uint64_t cgen_var_1302;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1302, 1);
+ stream->write((uint64_t*)&cgen_var_1302, 1 * 8);
+ stream->read((Display*)dpy, sizeof(Display));
+ VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkAcquireXlibDisplayEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkAcquireXlibDisplayEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetRandROutputDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ RROutput local_rrOutput;
+ local_physicalDevice = physicalDevice;
+ local_rrOutput = rrOutput;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1303;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1303, 1);
+ countingStream->write((uint64_t*)&cgen_var_1303, 1 * 8);
+ countingStream->write((Display*)dpy, sizeof(Display));
+ countingStream->write((RROutput*)&local_rrOutput, sizeof(RROutput));
+ uint64_t cgen_var_1304;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1304, 1);
+ countingStream->write((uint64_t*)&cgen_var_1304, 8);
+ }
+ uint32_t packetSize_vkGetRandROutputDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetRandROutputDisplayEXT = OP_vkGetRandROutputDisplayEXT;
+ stream->write(&opcode_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1305;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1305, 1);
+ stream->write((uint64_t*)&cgen_var_1305, 1 * 8);
+ stream->write((Display*)dpy, sizeof(Display));
+ stream->write((RROutput*)&local_rrOutput, sizeof(RROutput));
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1306;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1306, 1);
+ stream->write((uint64_t*)&cgen_var_1306, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->read((Display*)dpy, sizeof(Display));
+ uint64_t cgen_var_1307;
+ stream->read((uint64_t*)&cgen_var_1307, 8);
+ stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_1307, (VkDisplayKHR*)pDisplay, 1);
+ VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkGetRandROutputDisplayEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetRandROutputDisplayEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_display_surface_counter
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkSurfaceKHR local_surface;
+ local_physicalDevice = physicalDevice;
+ local_surface = surface;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1308;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1308, 1);
+ countingStream->write((uint64_t*)&cgen_var_1308, 1 * 8);
+ uint64_t cgen_var_1309;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1309, 1);
+ countingStream->write((uint64_t*)&cgen_var_1309, 1 * 8);
+ marshal_VkSurfaceCapabilities2EXT(countingStream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT = OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+ stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
+ uint64_t cgen_var_1310;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1310, 1);
+ stream->write((uint64_t*)&cgen_var_1310, 1 * 8);
+ uint64_t cgen_var_1311;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1311, 1);
+ stream->write((uint64_t*)&cgen_var_1311, 1 * 8);
+ marshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
+ unmarshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_display_control
+VkResult VkEncoder::vkDisplayPowerControlEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDisplayKHR local_display;
+ VkDisplayPowerInfoEXT* local_pDisplayPowerInfo;
+ local_device = device;
+ local_display = display;
+ local_pDisplayPowerInfo = nullptr;
+ if (pDisplayPowerInfo)
+ {
+ local_pDisplayPowerInfo = (VkDisplayPowerInfoEXT*)pool->alloc(sizeof(const VkDisplayPowerInfoEXT));
+ deepcopy_VkDisplayPowerInfoEXT(pool, pDisplayPowerInfo, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1312;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1312, 1);
+ countingStream->write((uint64_t*)&cgen_var_1312, 1 * 8);
+ uint64_t cgen_var_1313;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1313, 1);
+ countingStream->write((uint64_t*)&cgen_var_1313, 1 * 8);
+ marshal_VkDisplayPowerInfoEXT(countingStream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+ }
+ uint32_t packetSize_vkDisplayPowerControlEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDisplayPowerControlEXT = OP_vkDisplayPowerControlEXT;
+ stream->write(&opcode_vkDisplayPowerControlEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkDisplayPowerControlEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1314;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1314, 1);
+ stream->write((uint64_t*)&cgen_var_1314, 1 * 8);
+ uint64_t cgen_var_1315;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1315, 1);
+ stream->write((uint64_t*)&cgen_var_1315, 1 * 8);
+ marshal_VkDisplayPowerInfoEXT(stream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+ VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkDisplayPowerControlEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkDisplayPowerControlEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkRegisterDeviceEventEXT(
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDeviceEventInfoEXT* local_pDeviceEventInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pDeviceEventInfo = nullptr;
+ if (pDeviceEventInfo)
+ {
+ local_pDeviceEventInfo = (VkDeviceEventInfoEXT*)pool->alloc(sizeof(const VkDeviceEventInfoEXT));
+ deepcopy_VkDeviceEventInfoEXT(pool, pDeviceEventInfo, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1316;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1316, 1);
+ countingStream->write((uint64_t*)&cgen_var_1316, 1 * 8);
+ marshal_VkDeviceEventInfoEXT(countingStream, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1317 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1317);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1318;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1318, 1);
+ countingStream->write((uint64_t*)&cgen_var_1318, 8);
+ }
+ uint32_t packetSize_vkRegisterDeviceEventEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkRegisterDeviceEventEXT = OP_vkRegisterDeviceEventEXT;
+ stream->write(&opcode_vkRegisterDeviceEventEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkRegisterDeviceEventEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1319;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1319, 1);
+ stream->write((uint64_t*)&cgen_var_1319, 1 * 8);
+ marshal_VkDeviceEventInfoEXT(stream, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1320 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1320);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1321;
+ stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1321, 1);
+ stream->write((uint64_t*)&cgen_var_1321, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_1322;
+ stream->read((uint64_t*)&cgen_var_1322, 8);
+ stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1322, (VkFence*)pFence, 1);
+ VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkRegisterDeviceEventEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkRegisterDeviceEventEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkRegisterDisplayEventEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDisplayKHR local_display;
+ VkDisplayEventInfoEXT* local_pDisplayEventInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_display = display;
+ local_pDisplayEventInfo = nullptr;
+ if (pDisplayEventInfo)
+ {
+ local_pDisplayEventInfo = (VkDisplayEventInfoEXT*)pool->alloc(sizeof(const VkDisplayEventInfoEXT));
+ deepcopy_VkDisplayEventInfoEXT(pool, pDisplayEventInfo, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1323;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1323, 1);
+ countingStream->write((uint64_t*)&cgen_var_1323, 1 * 8);
+ uint64_t cgen_var_1324;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1324, 1);
+ countingStream->write((uint64_t*)&cgen_var_1324, 1 * 8);
+ marshal_VkDisplayEventInfoEXT(countingStream, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1325 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1325);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1326;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1326, 1);
+ countingStream->write((uint64_t*)&cgen_var_1326, 8);
+ }
+ uint32_t packetSize_vkRegisterDisplayEventEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkRegisterDisplayEventEXT = OP_vkRegisterDisplayEventEXT;
+ stream->write(&opcode_vkRegisterDisplayEventEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkRegisterDisplayEventEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1327;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1327, 1);
+ stream->write((uint64_t*)&cgen_var_1327, 1 * 8);
+ uint64_t cgen_var_1328;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1328, 1);
+ stream->write((uint64_t*)&cgen_var_1328, 1 * 8);
+ marshal_VkDisplayEventInfoEXT(stream, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1329 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1329);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1330;
+ stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1330, 1);
+ stream->write((uint64_t*)&cgen_var_1330, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_1331;
+ stream->read((uint64_t*)&cgen_var_1331, 8);
+ stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1331, (VkFence*)pFence, 1);
+ VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkRegisterDisplayEventEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkRegisterDisplayEventEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetSwapchainCounterEXT(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSwapchainKHR local_swapchain;
+ VkSurfaceCounterFlagBitsEXT local_counter;
+ local_device = device;
+ local_swapchain = swapchain;
+ local_counter = counter;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1332;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1332, 1);
+ countingStream->write((uint64_t*)&cgen_var_1332, 1 * 8);
+ uint64_t cgen_var_1333;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1333, 1);
+ countingStream->write((uint64_t*)&cgen_var_1333, 1 * 8);
+ countingStream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
+ countingStream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
+ }
+ uint32_t packetSize_vkGetSwapchainCounterEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetSwapchainCounterEXT = OP_vkGetSwapchainCounterEXT;
+ stream->write(&opcode_vkGetSwapchainCounterEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetSwapchainCounterEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1334;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1334, 1);
+ stream->write((uint64_t*)&cgen_var_1334, 1 * 8);
+ uint64_t cgen_var_1335;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1335, 1);
+ stream->write((uint64_t*)&cgen_var_1335, 1 * 8);
+ stream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
+ stream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
+ stream->read((uint64_t*)pCounterValue, sizeof(uint64_t));
+ VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkGetSwapchainCounterEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetSwapchainCounterEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSwapchainKHR local_swapchain;
+ local_device = device;
+ local_swapchain = swapchain;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1336;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1336, 1);
+ countingStream->write((uint64_t*)&cgen_var_1336, 1 * 8);
+ uint64_t cgen_var_1337;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1337, 1);
+ countingStream->write((uint64_t*)&cgen_var_1337, 1 * 8);
+ marshal_VkRefreshCycleDurationGOOGLE(countingStream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
+ }
+ uint32_t packetSize_vkGetRefreshCycleDurationGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetRefreshCycleDurationGOOGLE = OP_vkGetRefreshCycleDurationGOOGLE;
+ stream->write(&opcode_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
+ uint64_t cgen_var_1338;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1338, 1);
+ stream->write((uint64_t*)&cgen_var_1338, 1 * 8);
+ uint64_t cgen_var_1339;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1339, 1);
+ stream->write((uint64_t*)&cgen_var_1339, 1 * 8);
+ marshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
+ unmarshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
+ VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+ stream->read(&vkGetRefreshCycleDurationGOOGLE_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkSwapchainKHR local_swapchain;
+ local_device = device;
+ local_swapchain = swapchain;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1340;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1340, 1);
+ countingStream->write((uint64_t*)&cgen_var_1340, 1 * 8);
+ uint64_t cgen_var_1341;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1341, 1);
+ countingStream->write((uint64_t*)&cgen_var_1341, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1342 = (uint64_t)(uintptr_t)pPresentationTimingCount;
+ countingStream->putBe64(cgen_var_1342);
+ if (pPresentationTimingCount)
+ {
+ countingStream->write((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1343 = (uint64_t)(uintptr_t)pPresentationTimings;
+ countingStream->putBe64(cgen_var_1343);
+ if (pPresentationTimings)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
+ {
+ marshal_VkPastPresentationTimingGOOGLE(countingStream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetPastPresentationTimingGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPastPresentationTimingGOOGLE = OP_vkGetPastPresentationTimingGOOGLE;
+ stream->write(&opcode_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
+ uint64_t cgen_var_1344;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1344, 1);
+ stream->write((uint64_t*)&cgen_var_1344, 1 * 8);
+ uint64_t cgen_var_1345;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1345, 1);
+ stream->write((uint64_t*)&cgen_var_1345, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1346 = (uint64_t)(uintptr_t)pPresentationTimingCount;
+ stream->putBe64(cgen_var_1346);
+ if (pPresentationTimingCount)
+ {
+ stream->write((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1347 = (uint64_t)(uintptr_t)pPresentationTimings;
+ stream->putBe64(cgen_var_1347);
+ if (pPresentationTimings)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
+ {
+ marshal_VkPastPresentationTimingGOOGLE(stream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pPresentationTimingCount;
+ check_pPresentationTimingCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pPresentationTimingCount)
+ {
+ if (!(check_pPresentationTimingCount))
+ {
+ fprintf(stderr, "fatal: pPresentationTimingCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkPastPresentationTimingGOOGLE* check_pPresentationTimings;
+ check_pPresentationTimings = (VkPastPresentationTimingGOOGLE*)(uintptr_t)stream->getBe64();
+ if (pPresentationTimings)
+ {
+ if (!(check_pPresentationTimings))
+ {
+ fprintf(stderr, "fatal: pPresentationTimings inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
+ {
+ unmarshal_VkPastPresentationTimingGOOGLE(stream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+ }
+ }
+ VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+ stream->read(&vkGetPastPresentationTimingGOOGLE_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+void VkEncoder::vkCmdSetDiscardRectangleEXT(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_firstDiscardRectangle;
+ uint32_t local_discardRectangleCount;
+ VkRect2D* local_pDiscardRectangles;
+ local_commandBuffer = commandBuffer;
+ local_firstDiscardRectangle = firstDiscardRectangle;
+ local_discardRectangleCount = discardRectangleCount;
+ local_pDiscardRectangles = nullptr;
+ if (pDiscardRectangles)
+ {
+ local_pDiscardRectangles = (VkRect2D*)pool->alloc(((discardRectangleCount)) * sizeof(const VkRect2D));
+ for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
+ {
+ deepcopy_VkRect2D(pool, pDiscardRectangles + i, (VkRect2D*)(local_pDiscardRectangles + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1350;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1350, 1);
+ countingStream->write((uint64_t*)&cgen_var_1350, 1 * 8);
+ countingStream->write((uint32_t*)&local_firstDiscardRectangle, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
+ {
+ marshal_VkRect2D(countingStream, (VkRect2D*)(local_pDiscardRectangles + i));
+ }
+ }
+ uint32_t packetSize_vkCmdSetDiscardRectangleEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetDiscardRectangleEXT = OP_vkCmdSetDiscardRectangleEXT;
+ stream->write(&opcode_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1351;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1351, 1);
+ stream->write((uint64_t*)&cgen_var_1351, 1 * 8);
+ stream->write((uint32_t*)&local_firstDiscardRectangle, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
+ {
+ marshal_VkRect2D(stream, (VkRect2D*)(local_pDiscardRectangles + i));
+ }
+}
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void VkEncoder::vkSetHdrMetadataEXT(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ uint32_t local_swapchainCount;
+ VkSwapchainKHR* local_pSwapchains;
+ VkHdrMetadataEXT* local_pMetadata;
+ local_device = device;
+ local_swapchainCount = swapchainCount;
+ local_pSwapchains = nullptr;
+ if (pSwapchains)
+ {
+ local_pSwapchains = (VkSwapchainKHR*)pool->dupArray(pSwapchains, ((swapchainCount)) * sizeof(const VkSwapchainKHR));
+ }
+ local_pMetadata = nullptr;
+ if (pMetadata)
+ {
+ local_pMetadata = (VkHdrMetadataEXT*)pool->alloc(((swapchainCount)) * sizeof(const VkHdrMetadataEXT));
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+ {
+ deepcopy_VkHdrMetadataEXT(pool, pMetadata + i, (VkHdrMetadataEXT*)(local_pMetadata + i));
+ }
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1352;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1352, 1);
+ countingStream->write((uint64_t*)&cgen_var_1352, 1 * 8);
+ countingStream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
+ if (((swapchainCount)))
+ {
+ uint64_t* cgen_var_1353;
+ countingStream->alloc((void**)&cgen_var_1353, ((swapchainCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1353, ((swapchainCount)));
+ countingStream->write((uint64_t*)cgen_var_1353, ((swapchainCount)) * 8);
+ }
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+ {
+ marshal_VkHdrMetadataEXT(countingStream, (VkHdrMetadataEXT*)(local_pMetadata + i));
+ }
+ }
+ uint32_t packetSize_vkSetHdrMetadataEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkSetHdrMetadataEXT = OP_vkSetHdrMetadataEXT;
+ stream->write(&opcode_vkSetHdrMetadataEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkSetHdrMetadataEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1354;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1354, 1);
+ stream->write((uint64_t*)&cgen_var_1354, 1 * 8);
+ stream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
+ if (((swapchainCount)))
+ {
+ uint64_t* cgen_var_1355;
+ stream->alloc((void**)&cgen_var_1355, ((swapchainCount)) * 8);
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1355, ((swapchainCount)));
+ stream->write((uint64_t*)cgen_var_1355, ((swapchainCount)) * 8);
+ }
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
+ {
+ marshal_VkHdrMetadataEXT(stream, (VkHdrMetadataEXT*)(local_pMetadata + i));
+ }
+}
+
+#endif
+#ifdef VK_MVK_ios_surface
+VkResult VkEncoder::vkCreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkIOSSurfaceCreateInfoMVK* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkIOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkIOSSurfaceCreateInfoMVK));
+ deepcopy_VkIOSSurfaceCreateInfoMVK(pool, pCreateInfo, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1356;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1356, 1);
+ countingStream->write((uint64_t*)&cgen_var_1356, 1 * 8);
+ marshal_VkIOSSurfaceCreateInfoMVK(countingStream, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1357 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1357);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1358;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1358, 1);
+ countingStream->write((uint64_t*)&cgen_var_1358, 8);
+ }
+ uint32_t packetSize_vkCreateIOSSurfaceMVK = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateIOSSurfaceMVK = OP_vkCreateIOSSurfaceMVK;
+ stream->write(&opcode_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
+ uint64_t cgen_var_1359;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1359, 1);
+ stream->write((uint64_t*)&cgen_var_1359, 1 * 8);
+ marshal_VkIOSSurfaceCreateInfoMVK(stream, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1360 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1360);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1361;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1361, 1);
+ stream->write((uint64_t*)&cgen_var_1361, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_1362;
+ stream->read((uint64_t*)&cgen_var_1362, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1362, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateIOSSurfaceMVK_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateIOSSurfaceMVK_VkResult_return;
+}
+
+#endif
+#ifdef VK_MVK_macos_surface
+VkResult VkEncoder::vkCreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkMacOSSurfaceCreateInfoMVK* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkMacOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkMacOSSurfaceCreateInfoMVK));
+ deepcopy_VkMacOSSurfaceCreateInfoMVK(pool, pCreateInfo, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1363;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1363, 1);
+ countingStream->write((uint64_t*)&cgen_var_1363, 1 * 8);
+ marshal_VkMacOSSurfaceCreateInfoMVK(countingStream, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1364 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1364);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1365;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1365, 1);
+ countingStream->write((uint64_t*)&cgen_var_1365, 8);
+ }
+ uint32_t packetSize_vkCreateMacOSSurfaceMVK = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateMacOSSurfaceMVK = OP_vkCreateMacOSSurfaceMVK;
+ stream->write(&opcode_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
+ uint64_t cgen_var_1366;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1366, 1);
+ stream->write((uint64_t*)&cgen_var_1366, 1 * 8);
+ marshal_VkMacOSSurfaceCreateInfoMVK(stream, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1367 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1367);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1368;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1368, 1);
+ stream->write((uint64_t*)&cgen_var_1368, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ uint64_t cgen_var_1369;
+ stream->read((uint64_t*)&cgen_var_1369, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1369, (VkSurfaceKHR*)pSurface, 1);
+ VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateMacOSSurfaceMVK_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateMacOSSurfaceMVK_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT(
+ VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDebugUtilsObjectNameInfoEXT* local_pNameInfo;
+ local_device = device;
+ local_pNameInfo = nullptr;
+ if (pNameInfo)
+ {
+ local_pNameInfo = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectNameInfoEXT));
+ deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, pNameInfo, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1370;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1370, 1);
+ countingStream->write((uint64_t*)&cgen_var_1370, 1 * 8);
+ marshal_VkDebugUtilsObjectNameInfoEXT(countingStream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+ }
+ uint32_t packetSize_vkSetDebugUtilsObjectNameEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkSetDebugUtilsObjectNameEXT = OP_vkSetDebugUtilsObjectNameEXT;
+ stream->write(&opcode_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1371;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1371, 1);
+ stream->write((uint64_t*)&cgen_var_1371, 1 * 8);
+ marshal_VkDebugUtilsObjectNameInfoEXT(stream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+ VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT(
+ VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkDebugUtilsObjectTagInfoEXT* local_pTagInfo;
+ local_device = device;
+ local_pTagInfo = nullptr;
+ if (pTagInfo)
+ {
+ local_pTagInfo = (VkDebugUtilsObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectTagInfoEXT));
+ deepcopy_VkDebugUtilsObjectTagInfoEXT(pool, pTagInfo, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1372;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1372, 1);
+ countingStream->write((uint64_t*)&cgen_var_1372, 1 * 8);
+ marshal_VkDebugUtilsObjectTagInfoEXT(countingStream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+ }
+ uint32_t packetSize_vkSetDebugUtilsObjectTagEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkSetDebugUtilsObjectTagEXT = OP_vkSetDebugUtilsObjectTagEXT;
+ stream->write(&opcode_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1373;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1373, 1);
+ stream->write((uint64_t*)&cgen_var_1373, 1 * 8);
+ marshal_VkDebugUtilsObjectTagInfoEXT(stream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+ VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
+
+void VkEncoder::vkQueueBeginDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ VkDebugUtilsLabelEXT* local_pLabelInfo;
+ local_queue = queue;
+ local_pLabelInfo = nullptr;
+ if (pLabelInfo)
+ {
+ local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+ deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1374;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1374, 1);
+ countingStream->write((uint64_t*)&cgen_var_1374, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ uint32_t packetSize_vkQueueBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueueBeginDebugUtilsLabelEXT = OP_vkQueueBeginDebugUtilsLabelEXT;
+ stream->write(&opcode_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1375;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1375, 1);
+ stream->write((uint64_t*)&cgen_var_1375, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+}
+
+void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
+ VkQueue queue)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ local_queue = queue;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1376;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1376, 1);
+ countingStream->write((uint64_t*)&cgen_var_1376, 1 * 8);
+ }
+ uint32_t packetSize_vkQueueEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueueEndDebugUtilsLabelEXT = OP_vkQueueEndDebugUtilsLabelEXT;
+ stream->write(&opcode_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1377;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1377, 1);
+ stream->write((uint64_t*)&cgen_var_1377, 1 * 8);
+}
+
+void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ VkDebugUtilsLabelEXT* local_pLabelInfo;
+ local_queue = queue;
+ local_pLabelInfo = nullptr;
+ if (pLabelInfo)
+ {
+ local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+ deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1378;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1378, 1);
+ countingStream->write((uint64_t*)&cgen_var_1378, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ uint32_t packetSize_vkQueueInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueueInsertDebugUtilsLabelEXT = OP_vkQueueInsertDebugUtilsLabelEXT;
+ stream->write(&opcode_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1379;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1379, 1);
+ stream->write((uint64_t*)&cgen_var_1379, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+}
+
+void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkDebugUtilsLabelEXT* local_pLabelInfo;
+ local_commandBuffer = commandBuffer;
+ local_pLabelInfo = nullptr;
+ if (pLabelInfo)
+ {
+ local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+ deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1380;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1380, 1);
+ countingStream->write((uint64_t*)&cgen_var_1380, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ uint32_t packetSize_vkCmdBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBeginDebugUtilsLabelEXT = OP_vkCmdBeginDebugUtilsLabelEXT;
+ stream->write(&opcode_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1381;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1381, 1);
+ stream->write((uint64_t*)&cgen_var_1381, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+}
+
+void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ local_commandBuffer = commandBuffer;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1382;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1382, 1);
+ countingStream->write((uint64_t*)&cgen_var_1382, 1 * 8);
+ }
+ uint32_t packetSize_vkCmdEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdEndDebugUtilsLabelEXT = OP_vkCmdEndDebugUtilsLabelEXT;
+ stream->write(&opcode_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1383;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1383, 1);
+ stream->write((uint64_t*)&cgen_var_1383, 1 * 8);
+}
+
+void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkDebugUtilsLabelEXT* local_pLabelInfo;
+ local_commandBuffer = commandBuffer;
+ local_pLabelInfo = nullptr;
+ if (pLabelInfo)
+ {
+ local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+ deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1384;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1384, 1);
+ countingStream->write((uint64_t*)&cgen_var_1384, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ uint32_t packetSize_vkCmdInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdInsertDebugUtilsLabelEXT = OP_vkCmdInsertDebugUtilsLabelEXT;
+ stream->write(&opcode_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1385;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1385, 1);
+ stream->write((uint64_t*)&cgen_var_1385, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+}
+
+VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT(
+ VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkDebugUtilsMessengerCreateInfoEXT* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkDebugUtilsMessengerCreateInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCreateInfoEXT));
+ deepcopy_VkDebugUtilsMessengerCreateInfoEXT(pool, pCreateInfo, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1386;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1386, 1);
+ countingStream->write((uint64_t*)&cgen_var_1386, 1 * 8);
+ marshal_VkDebugUtilsMessengerCreateInfoEXT(countingStream, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1387 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1387);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1388;
+ countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1388, 1);
+ countingStream->write((uint64_t*)&cgen_var_1388, 8);
+ }
+ uint32_t packetSize_vkCreateDebugUtilsMessengerEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateDebugUtilsMessengerEXT = OP_vkCreateDebugUtilsMessengerEXT;
+ stream->write(&opcode_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1389;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1389, 1);
+ stream->write((uint64_t*)&cgen_var_1389, 1 * 8);
+ marshal_VkDebugUtilsMessengerCreateInfoEXT(stream, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1390 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1390);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1391;
+ stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1391, 1);
+ stream->write((uint64_t*)&cgen_var_1391, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_1392;
+ stream->read((uint64_t*)&cgen_var_1392, 8);
+ stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_1392, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateDebugUtilsMessengerEXT_VkResult_return;
+}
+
+void VkEncoder::vkDestroyDebugUtilsMessengerEXT(
+ VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkDebugUtilsMessengerEXT local_messenger;
+ VkAllocationCallbacks* local_pAllocator;
+ local_instance = instance;
+ local_messenger = messenger;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1393;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1393, 1);
+ countingStream->write((uint64_t*)&cgen_var_1393, 1 * 8);
+ uint64_t cgen_var_1394;
+ countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1394, 1);
+ countingStream->write((uint64_t*)&cgen_var_1394, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1395 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1395);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyDebugUtilsMessengerEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyDebugUtilsMessengerEXT = OP_vkDestroyDebugUtilsMessengerEXT;
+ stream->write(&opcode_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1396;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1396, 1);
+ stream->write((uint64_t*)&cgen_var_1396, 1 * 8);
+ uint64_t cgen_var_1397;
+ stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1397, 1);
+ stream->write((uint64_t*)&cgen_var_1397, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1398 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1398);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkDebugUtilsMessengerEXT((VkDebugUtilsMessengerEXT*)&messenger);
+}
+
+void VkEncoder::vkSubmitDebugUtilsMessageEXT(
+ VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkInstance local_instance;
+ VkDebugUtilsMessageSeverityFlagBitsEXT local_messageSeverity;
+ VkDebugUtilsMessageTypeFlagsEXT local_messageTypes;
+ VkDebugUtilsMessengerCallbackDataEXT* local_pCallbackData;
+ local_instance = instance;
+ local_messageSeverity = messageSeverity;
+ local_messageTypes = messageTypes;
+ local_pCallbackData = nullptr;
+ if (pCallbackData)
+ {
+ local_pCallbackData = (VkDebugUtilsMessengerCallbackDataEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCallbackDataEXT));
+ deepcopy_VkDebugUtilsMessengerCallbackDataEXT(pool, pCallbackData, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1399;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1399, 1);
+ countingStream->write((uint64_t*)&cgen_var_1399, 1 * 8);
+ countingStream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
+ countingStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ marshal_VkDebugUtilsMessengerCallbackDataEXT(countingStream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+ }
+ uint32_t packetSize_vkSubmitDebugUtilsMessageEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkSubmitDebugUtilsMessageEXT = OP_vkSubmitDebugUtilsMessageEXT;
+ stream->write(&opcode_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1400;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1400, 1);
+ stream->write((uint64_t*)&cgen_var_1400, 1 * 8);
+ stream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
+ stream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ marshal_VkDebugUtilsMessengerCallbackDataEXT(stream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+}
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID(
+ VkDevice device,
+ const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ AHardwareBuffer* local_buffer;
+ local_device = device;
+ local_buffer = nullptr;
+ if (buffer)
+ {
+ local_buffer = (AHardwareBuffer*)pool->dupArray(buffer, sizeof(const AHardwareBuffer));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1401;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1401, 1);
+ countingStream->write((uint64_t*)&cgen_var_1401, 1 * 8);
+ countingStream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
+ marshal_VkAndroidHardwareBufferPropertiesANDROID(countingStream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
+ }
+ uint32_t packetSize_vkGetAndroidHardwareBufferPropertiesANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetAndroidHardwareBufferPropertiesANDROID = OP_vkGetAndroidHardwareBufferPropertiesANDROID;
+ stream->write(&opcode_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
+ uint64_t cgen_var_1402;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1402, 1);
+ stream->write((uint64_t*)&cgen_var_1402, 1 * 8);
+ stream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
+ marshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
+ unmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
+ VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
+ stream->read(&vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID(
+ VkDevice device,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* local_pInfo;
+ local_device = device;
+ local_pInfo = nullptr;
+ if (pInfo)
+ {
+ local_pInfo = (VkMemoryGetAndroidHardwareBufferInfoANDROID*)pool->alloc(sizeof(const VkMemoryGetAndroidHardwareBufferInfoANDROID));
+ deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(pool, pInfo, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1403;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1403, 1);
+ countingStream->write((uint64_t*)&cgen_var_1403, 1 * 8);
+ marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(countingStream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+ countingStream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
+ }
+ uint32_t packetSize_vkGetMemoryAndroidHardwareBufferANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetMemoryAndroidHardwareBufferANDROID = OP_vkGetMemoryAndroidHardwareBufferANDROID;
+ stream->write(&opcode_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
+ uint64_t cgen_var_1404;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1404, 1);
+ stream->write((uint64_t*)&cgen_var_1404, 1 * 8);
+ marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(stream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+ stream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
+ stream->read((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
+ VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
+ stream->read(&vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void VkEncoder::vkCmdSetSampleLocationsEXT(
+ VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkSampleLocationsInfoEXT* local_pSampleLocationsInfo;
+ local_commandBuffer = commandBuffer;
+ local_pSampleLocationsInfo = nullptr;
+ if (pSampleLocationsInfo)
+ {
+ local_pSampleLocationsInfo = (VkSampleLocationsInfoEXT*)pool->alloc(sizeof(const VkSampleLocationsInfoEXT));
+ deepcopy_VkSampleLocationsInfoEXT(pool, pSampleLocationsInfo, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1405;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1405, 1);
+ countingStream->write((uint64_t*)&cgen_var_1405, 1 * 8);
+ marshal_VkSampleLocationsInfoEXT(countingStream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+ }
+ uint32_t packetSize_vkCmdSetSampleLocationsEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetSampleLocationsEXT = OP_vkCmdSetSampleLocationsEXT;
+ stream->write(&opcode_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1406;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1406, 1);
+ stream->write((uint64_t*)&cgen_var_1406, 1 * 8);
+ marshal_VkSampleLocationsInfoEXT(stream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+}
+
+void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT(
+ VkPhysicalDevice physicalDevice,
+ VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkPhysicalDevice local_physicalDevice;
+ VkSampleCountFlagBits local_samples;
+ local_physicalDevice = physicalDevice;
+ local_samples = samples;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1407;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1407, 1);
+ countingStream->write((uint64_t*)&cgen_var_1407, 1 * 8);
+ countingStream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
+ marshal_VkMultisamplePropertiesEXT(countingStream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
+ }
+ uint32_t packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT = OP_vkGetPhysicalDeviceMultisamplePropertiesEXT;
+ stream->write(&opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1408;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1408, 1);
+ stream->write((uint64_t*)&cgen_var_1408, 1 * 8);
+ stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
+ marshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
+ unmarshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
+}
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+VkResult VkEncoder::vkCreateValidationCacheEXT(
+ VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkValidationCacheCreateInfoEXT* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkValidationCacheCreateInfoEXT*)pool->alloc(sizeof(const VkValidationCacheCreateInfoEXT));
+ deepcopy_VkValidationCacheCreateInfoEXT(pool, pCreateInfo, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1409;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1409, 1);
+ countingStream->write((uint64_t*)&cgen_var_1409, 1 * 8);
+ marshal_VkValidationCacheCreateInfoEXT(countingStream, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1410 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1410);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1411;
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1411, 1);
+ countingStream->write((uint64_t*)&cgen_var_1411, 8);
+ }
+ uint32_t packetSize_vkCreateValidationCacheEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateValidationCacheEXT = OP_vkCreateValidationCacheEXT;
+ stream->write(&opcode_vkCreateValidationCacheEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateValidationCacheEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1412;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1412, 1);
+ stream->write((uint64_t*)&cgen_var_1412, 1 * 8);
+ marshal_VkValidationCacheCreateInfoEXT(stream, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1413 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1413);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1414;
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1414, 1);
+ stream->write((uint64_t*)&cgen_var_1414, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_1415;
+ stream->read((uint64_t*)&cgen_var_1415, 8);
+ stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_1415, (VkValidationCacheEXT*)pValidationCache, 1);
+ stream->unsetHandleMapping();
+ VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateValidationCacheEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkCreateValidationCacheEXT_VkResult_return;
+}
+
+void VkEncoder::vkDestroyValidationCacheEXT(
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkValidationCacheEXT local_validationCache;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_validationCache = validationCache;
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1416;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1416, 1);
+ countingStream->write((uint64_t*)&cgen_var_1416, 1 * 8);
+ uint64_t cgen_var_1417;
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1417, 1);
+ countingStream->write((uint64_t*)&cgen_var_1417, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1418 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1418);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ }
+ uint32_t packetSize_vkDestroyValidationCacheEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkDestroyValidationCacheEXT = OP_vkDestroyValidationCacheEXT;
+ stream->write(&opcode_vkDestroyValidationCacheEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkDestroyValidationCacheEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1419;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1419, 1);
+ stream->write((uint64_t*)&cgen_var_1419, 1 * 8);
+ uint64_t cgen_var_1420;
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1420, 1);
+ stream->write((uint64_t*)&cgen_var_1420, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1421 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1421);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ resources->destroyMapping()->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&validationCache);
+}
+
+VkResult VkEncoder::vkMergeValidationCachesEXT(
+ VkDevice device,
+ VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkValidationCacheEXT local_dstCache;
+ uint32_t local_srcCacheCount;
+ VkValidationCacheEXT* local_pSrcCaches;
+ local_device = device;
+ local_dstCache = dstCache;
+ local_srcCacheCount = srcCacheCount;
+ local_pSrcCaches = nullptr;
+ if (pSrcCaches)
+ {
+ local_pSrcCaches = (VkValidationCacheEXT*)pool->dupArray(pSrcCaches, ((srcCacheCount)) * sizeof(const VkValidationCacheEXT));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1422;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1422, 1);
+ countingStream->write((uint64_t*)&cgen_var_1422, 1 * 8);
+ uint64_t cgen_var_1423;
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1423, 1);
+ countingStream->write((uint64_t*)&cgen_var_1423, 1 * 8);
+ countingStream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
+ if (((srcCacheCount)))
+ {
+ uint64_t* cgen_var_1424;
+ countingStream->alloc((void**)&cgen_var_1424, ((srcCacheCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1424, ((srcCacheCount)));
+ countingStream->write((uint64_t*)cgen_var_1424, ((srcCacheCount)) * 8);
+ }
+ }
+ uint32_t packetSize_vkMergeValidationCachesEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkMergeValidationCachesEXT = OP_vkMergeValidationCachesEXT;
+ stream->write(&opcode_vkMergeValidationCachesEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkMergeValidationCachesEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1425;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1425, 1);
+ stream->write((uint64_t*)&cgen_var_1425, 1 * 8);
+ uint64_t cgen_var_1426;
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1426, 1);
+ stream->write((uint64_t*)&cgen_var_1426, 1 * 8);
+ stream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
+ if (((srcCacheCount)))
+ {
+ uint64_t* cgen_var_1427;
+ stream->alloc((void**)&cgen_var_1427, ((srcCacheCount)) * 8);
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1427, ((srcCacheCount)));
+ stream->write((uint64_t*)cgen_var_1427, ((srcCacheCount)) * 8);
+ }
+ VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkMergeValidationCachesEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkMergeValidationCachesEXT_VkResult_return;
+}
+
+VkResult VkEncoder::vkGetValidationCacheDataEXT(
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkValidationCacheEXT local_validationCache;
+ local_device = device;
+ local_validationCache = validationCache;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1428;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1428, 1);
+ countingStream->write((uint64_t*)&cgen_var_1428, 1 * 8);
+ uint64_t cgen_var_1429;
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1429, 1);
+ countingStream->write((uint64_t*)&cgen_var_1429, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1430 = (uint64_t)(uintptr_t)pDataSize;
+ countingStream->putBe64(cgen_var_1430);
+ if (pDataSize)
+ {
+ uint64_t cgen_var_1431 = (uint64_t)(*pDataSize);
+ countingStream->putBe64(cgen_var_1431);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1432 = (uint64_t)(uintptr_t)pData;
+ countingStream->putBe64(cgen_var_1432);
+ if (pData)
+ {
+ countingStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+ }
+ }
+ uint32_t packetSize_vkGetValidationCacheDataEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetValidationCacheDataEXT = OP_vkGetValidationCacheDataEXT;
+ stream->write(&opcode_vkGetValidationCacheDataEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetValidationCacheDataEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1433;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1433, 1);
+ stream->write((uint64_t*)&cgen_var_1433, 1 * 8);
+ uint64_t cgen_var_1434;
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1434, 1);
+ stream->write((uint64_t*)&cgen_var_1434, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1435 = (uint64_t)(uintptr_t)pDataSize;
+ stream->putBe64(cgen_var_1435);
+ if (pDataSize)
+ {
+ uint64_t cgen_var_1436 = (uint64_t)(*pDataSize);
+ stream->putBe64(cgen_var_1436);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1437 = (uint64_t)(uintptr_t)pData;
+ stream->putBe64(cgen_var_1437);
+ if (pData)
+ {
+ stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+ }
+ // WARNING PTR CHECK
+ size_t* check_pDataSize;
+ check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
+ if (pDataSize)
+ {
+ if (!(check_pDataSize))
+ {
+ fprintf(stderr, "fatal: pDataSize inconsistent between guest and host\n");
+ }
+ (*pDataSize) = (size_t)stream->getBe64();
+ }
+ // WARNING PTR CHECK
+ void* check_pData;
+ check_pData = (void*)(uintptr_t)stream->getBe64();
+ if (pData)
+ {
+ if (!(check_pData))
+ {
+ fprintf(stderr, "fatal: pData inconsistent between guest and host\n");
+ }
+ stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+ }
+ VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkGetValidationCacheDataEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetValidationCacheDataEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkExternalMemoryHandleTypeFlagBits local_handleType;
+ void* local_pHostPointer;
+ local_device = device;
+ local_handleType = handleType;
+ local_pHostPointer = nullptr;
+ if (pHostPointer)
+ {
+ local_pHostPointer = (void*)pool->dupArray(pHostPointer, sizeof(const uint8_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1441;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1441, 1);
+ countingStream->write((uint64_t*)&cgen_var_1441, 1 * 8);
+ countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1442 = (uint64_t)(uintptr_t)local_pHostPointer;
+ countingStream->putBe64(cgen_var_1442);
+ if (local_pHostPointer)
+ {
+ countingStream->write((void*)local_pHostPointer, sizeof(uint8_t));
+ }
+ marshal_VkMemoryHostPointerPropertiesEXT(countingStream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+ }
+ uint32_t packetSize_vkGetMemoryHostPointerPropertiesEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetMemoryHostPointerPropertiesEXT = OP_vkGetMemoryHostPointerPropertiesEXT;
+ stream->write(&opcode_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1443;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1443, 1);
+ stream->write((uint64_t*)&cgen_var_1443, 1 * 8);
+ stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1444 = (uint64_t)(uintptr_t)local_pHostPointer;
+ stream->putBe64(cgen_var_1444);
+ if (local_pHostPointer)
+ {
+ stream->write((void*)local_pHostPointer, sizeof(uint8_t));
+ }
+ marshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+ unmarshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+ VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+ stream->read(&vkGetMemoryHostPointerPropertiesEXT_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
+
+#endif
+#ifdef VK_AMD_buffer_marker
+void VkEncoder::vkCmdWriteBufferMarkerAMD(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ uint32_t marker)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkPipelineStageFlagBits local_pipelineStage;
+ VkBuffer local_dstBuffer;
+ VkDeviceSize local_dstOffset;
+ uint32_t local_marker;
+ local_commandBuffer = commandBuffer;
+ local_pipelineStage = pipelineStage;
+ local_dstBuffer = dstBuffer;
+ local_dstOffset = dstOffset;
+ local_marker = marker;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1445;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1445, 1);
+ countingStream->write((uint64_t*)&cgen_var_1445, 1 * 8);
+ countingStream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+ uint64_t cgen_var_1446;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1446, 1);
+ countingStream->write((uint64_t*)&cgen_var_1446, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_marker, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdWriteBufferMarkerAMD = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdWriteBufferMarkerAMD = OP_vkCmdWriteBufferMarkerAMD;
+ stream->write(&opcode_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
+ uint64_t cgen_var_1447;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1447, 1);
+ stream->write((uint64_t*)&cgen_var_1447, 1 * 8);
+ stream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+ uint64_t cgen_var_1448;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1448, 1);
+ stream->write((uint64_t*)&cgen_var_1448, 1 * 8);
+ stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_marker, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void VkEncoder::vkCmdSetCheckpointNV(
+ VkCommandBuffer commandBuffer,
+ const void* pCheckpointMarker)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ void* local_pCheckpointMarker;
+ local_commandBuffer = commandBuffer;
+ local_pCheckpointMarker = nullptr;
+ if (pCheckpointMarker)
+ {
+ local_pCheckpointMarker = (void*)pool->dupArray(pCheckpointMarker, sizeof(const uint8_t));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1449;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1449, 1);
+ countingStream->write((uint64_t*)&cgen_var_1449, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1450 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
+ countingStream->putBe64(cgen_var_1450);
+ if (local_pCheckpointMarker)
+ {
+ countingStream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
+ }
+ }
+ uint32_t packetSize_vkCmdSetCheckpointNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdSetCheckpointNV = OP_vkCmdSetCheckpointNV;
+ stream->write(&opcode_vkCmdSetCheckpointNV, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetCheckpointNV, sizeof(uint32_t));
+ uint64_t cgen_var_1451;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1451, 1);
+ stream->write((uint64_t*)&cgen_var_1451, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1452 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
+ stream->putBe64(cgen_var_1452);
+ if (local_pCheckpointMarker)
+ {
+ stream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
+ }
+}
+
+void VkEncoder::vkGetQueueCheckpointDataNV(
+ VkQueue queue,
+ uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData)
+{
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
+ local_queue = queue;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1453;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1453, 1);
+ countingStream->write((uint64_t*)&cgen_var_1453, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1454 = (uint64_t)(uintptr_t)pCheckpointDataCount;
+ countingStream->putBe64(cgen_var_1454);
+ if (pCheckpointDataCount)
+ {
+ countingStream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1455 = (uint64_t)(uintptr_t)pCheckpointData;
+ countingStream->putBe64(cgen_var_1455);
+ if (pCheckpointData)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
+ {
+ marshal_VkCheckpointDataNV(countingStream, (VkCheckpointDataNV*)(pCheckpointData + i));
+ }
+ }
+ }
+ uint32_t packetSize_vkGetQueueCheckpointDataNV = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetQueueCheckpointDataNV = OP_vkGetQueueCheckpointDataNV;
+ stream->write(&opcode_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
+ uint64_t cgen_var_1456;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1456, 1);
+ stream->write((uint64_t*)&cgen_var_1456, 1 * 8);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1457 = (uint64_t)(uintptr_t)pCheckpointDataCount;
+ stream->putBe64(cgen_var_1457);
+ if (pCheckpointDataCount)
+ {
+ stream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1458 = (uint64_t)(uintptr_t)pCheckpointData;
+ stream->putBe64(cgen_var_1458);
+ if (pCheckpointData)
+ {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
+ {
+ marshal_VkCheckpointDataNV(stream, (VkCheckpointDataNV*)(pCheckpointData + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint32_t* check_pCheckpointDataCount;
+ check_pCheckpointDataCount = (uint32_t*)(uintptr_t)stream->getBe64();
+ if (pCheckpointDataCount)
+ {
+ if (!(check_pCheckpointDataCount))
+ {
+ fprintf(stderr, "fatal: pCheckpointDataCount inconsistent between guest and host\n");
+ }
+ stream->read((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
+ }
+ // WARNING PTR CHECK
+ VkCheckpointDataNV* check_pCheckpointData;
+ check_pCheckpointData = (VkCheckpointDataNV*)(uintptr_t)stream->getBe64();
+ if (pCheckpointData)
+ {
+ if (!(check_pCheckpointData))
+ {
+ fprintf(stderr, "fatal: pCheckpointData inconsistent between guest and host\n");
+ }
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
+ {
+ unmarshal_VkCheckpointDataNV(stream, (VkCheckpointDataNV*)(pCheckpointData + i));
+ }
+ }
+}
+
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
new file mode 100644
index 0000000..2eacb67
--- /dev/null
+++ b/system/vulkan_enc/VkEncoder.h
@@ -0,0 +1,1750 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module VkEncoder
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "goldfish_vk_private_defs.h"
+#include <memory>
+class IOStream;
+
+
+namespace goldfish_vk {
+
+
+class VkEncoder {
+public:
+ VkEncoder(IOStream* stream);
+ ~VkEncoder();
+#ifdef VK_VERSION_1_0
+ VkResult vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+ void vkDestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkEnumeratePhysicalDevices(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices);
+ void vkGetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures);
+ void vkGetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties);
+ VkResult vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties);
+ void vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties);
+ void vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties);
+ void vkGetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ PFN_vkVoidFunction vkGetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName);
+ PFN_vkVoidFunction vkGetDeviceProcAddr(
+ VkDevice device,
+ const char* pName);
+ VkResult vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+ void vkDestroyDevice(
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkEnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+ VkResult vkEnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+ VkResult vkEnumerateInstanceLayerProperties(
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+ VkResult vkEnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+ void vkGetDeviceQueue(
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue);
+ VkResult vkQueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence);
+ VkResult vkQueueWaitIdle(
+ VkQueue queue);
+ VkResult vkDeviceWaitIdle(
+ VkDevice device);
+ VkResult vkAllocateMemory(
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory);
+ void vkFreeMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkMapMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData);
+ void vkUnmapMemory(
+ VkDevice device,
+ VkDeviceMemory memory);
+ VkResult vkFlushMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+ VkResult vkInvalidateMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+ void vkGetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes);
+ VkResult vkBindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+ VkResult vkBindImageMemory(
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+ void vkGetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements);
+ void vkGetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements);
+ void vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+ void vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties);
+ VkResult vkQueueBindSparse(
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence);
+ VkResult vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ void vkDestroyFence(
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkResetFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences);
+ VkResult vkGetFenceStatus(
+ VkDevice device,
+ VkFence fence);
+ VkResult vkWaitForFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout);
+ VkResult vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore);
+ void vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent);
+ void vkDestroyEvent(
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkGetEventStatus(
+ VkDevice device,
+ VkEvent event);
+ VkResult vkSetEvent(
+ VkDevice device,
+ VkEvent event);
+ VkResult vkResetEvent(
+ VkDevice device,
+ VkEvent event);
+ VkResult vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool);
+ void vkDestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkGetQueryPoolResults(
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+ VkResult vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer);
+ void vkDestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView);
+ void vkDestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage);
+ void vkDestroyImage(
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator);
+ void vkGetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout);
+ VkResult vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView);
+ void vkDestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule);
+ void vkDestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache);
+ void vkDestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData);
+ VkResult vkMergePipelineCaches(
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches);
+ VkResult vkCreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+ VkResult vkCreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+ void vkDestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout);
+ void vkDestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler);
+ void vkDestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout);
+ void vkDestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool);
+ void vkDestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags);
+ VkResult vkAllocateDescriptorSets(
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets);
+ VkResult vkFreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets);
+ void vkUpdateDescriptorSets(
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies);
+ VkResult vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer);
+ void vkDestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+ void vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator);
+ void vkGetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity);
+ VkResult vkCreateCommandPool(
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool);
+ void vkDestroyCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkResetCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags);
+ VkResult vkAllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers);
+ void vkFreeCommandBuffers(
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+ VkResult vkBeginCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo);
+ VkResult vkEndCommandBuffer(
+ VkCommandBuffer commandBuffer);
+ VkResult vkResetCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags);
+ void vkCmdBindPipeline(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline);
+ void vkCmdSetViewport(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport* pViewports);
+ void vkCmdSetScissor(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors);
+ void vkCmdSetLineWidth(
+ VkCommandBuffer commandBuffer,
+ float lineWidth);
+ void vkCmdSetDepthBias(
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor);
+ void vkCmdSetBlendConstants(
+ VkCommandBuffer commandBuffer,
+ const float blendConstants);
+ void vkCmdSetDepthBounds(
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds);
+ void vkCmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask);
+ void vkCmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask);
+ void vkCmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference);
+ void vkCmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets);
+ void vkCmdBindIndexBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType);
+ void vkCmdBindVertexBuffers(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets);
+ void vkCmdDraw(
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance);
+ void vkCmdDrawIndexed(
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance);
+ void vkCmdDrawIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+ void vkCmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+ void vkCmdDispatch(
+ VkCommandBuffer commandBuffer,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+ void vkCmdDispatchIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset);
+ void vkCmdCopyBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions);
+ void vkCmdCopyImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions);
+ void vkCmdBlitImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter);
+ void vkCmdCopyBufferToImage(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+ void vkCmdCopyImageToBuffer(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+ void vkCmdUpdateBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData);
+ void vkCmdFillBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data);
+ void vkCmdClearColorImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+ void vkCmdClearDepthStencilImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+ void vkCmdClearAttachments(
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects);
+ void vkCmdResolveImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions);
+ void vkCmdSetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+ void vkCmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+ void vkCmdWaitEvents(
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers);
+ void vkCmdPipelineBarrier(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers);
+ void vkCmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags);
+ void vkCmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query);
+ void vkCmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount);
+ void vkCmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query);
+ void vkCmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+ void vkCmdPushConstants(
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues);
+ void vkCmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents);
+ void vkCmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents);
+ void vkCmdEndRenderPass(
+ VkCommandBuffer commandBuffer);
+ void vkCmdExecuteCommands(
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+#endif
+#ifdef VK_VERSION_1_1
+ VkResult vkEnumerateInstanceVersion(
+ uint32_t* pApiVersion);
+ VkResult vkBindBufferMemory2(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos);
+ VkResult vkBindImageMemory2(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos);
+ void vkGetDeviceGroupPeerMemoryFeatures(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+ void vkCmdSetDeviceMask(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask);
+ void vkCmdDispatchBase(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+ VkResult vkEnumeratePhysicalDeviceGroups(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+ void vkGetImageMemoryRequirements2(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ void vkGetBufferMemoryRequirements2(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ void vkGetImageSparseMemoryRequirements2(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+ void vkGetPhysicalDeviceFeatures2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures);
+ void vkGetPhysicalDeviceProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties);
+ void vkGetPhysicalDeviceFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties);
+ VkResult vkGetPhysicalDeviceImageFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties);
+ void vkGetPhysicalDeviceQueueFamilyProperties2(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties);
+ void vkGetPhysicalDeviceMemoryProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+ void vkGetPhysicalDeviceSparseImageFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties);
+ void vkTrimCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags);
+ void vkGetDeviceQueue2(
+ VkDevice device,
+ const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue);
+ VkResult vkCreateSamplerYcbcrConversion(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion);
+ void vkDestroySamplerYcbcrConversion(
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateDescriptorUpdateTemplate(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+ void vkDestroyDescriptorUpdateTemplate(
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator);
+ void vkUpdateDescriptorSetWithTemplate(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData);
+ void vkGetPhysicalDeviceExternalBufferProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties);
+ void vkGetPhysicalDeviceExternalFenceProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties);
+ void vkGetPhysicalDeviceExternalSemaphoreProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+ void vkGetDescriptorSetLayoutSupport(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_surface
+ void vkDestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported);
+ VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+ VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats);
+ VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes);
+#endif
+#ifdef VK_KHR_swapchain
+ VkResult vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain);
+ void vkDestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages);
+ VkResult vkAcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex);
+ VkResult vkQueuePresentKHR(
+ VkQueue queue,
+ const VkPresentInfoKHR* pPresentInfo);
+ VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
+ VkResult vkGetDeviceGroupSurfacePresentModesKHR(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHR* pModes);
+ VkResult vkGetPhysicalDevicePresentRectanglesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects);
+ VkResult vkAcquireNextImage2KHR(
+ VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex);
+#endif
+#ifdef VK_KHR_display
+ VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties);
+ VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties);
+ VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays);
+ VkResult vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties);
+ VkResult vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode);
+ VkResult vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+ VkResult vkCreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_display_swapchain
+ VkResult vkCreateSharedSwapchainsKHR(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains);
+#endif
+#ifdef VK_KHR_xlib_surface
+ VkResult vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID);
+#endif
+#ifdef VK_KHR_xcb_surface
+ VkResult vkCreateXcbSurfaceKHR(
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id);
+#endif
+#ifdef VK_KHR_wayland_surface
+ VkResult vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ wl_display* display);
+#endif
+#ifdef VK_KHR_mir_surface
+ VkResult vkCreateMirSurfaceKHR(
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection);
+#endif
+#ifdef VK_KHR_android_surface
+ VkResult vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_win32_surface
+ VkResult vkCreateWin32SurfaceKHR(
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex);
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+ void vkGetPhysicalDeviceFeatures2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures);
+ void vkGetPhysicalDeviceProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties);
+ void vkGetPhysicalDeviceFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties);
+ VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties);
+ void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties);
+ void vkGetPhysicalDeviceMemoryProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+ void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties);
+#endif
+#ifdef VK_KHR_device_group
+ void vkGetDeviceGroupPeerMemoryFeaturesKHR(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+ void vkCmdSetDeviceMaskKHR(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask);
+ void vkCmdDispatchBaseKHR(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+ void vkTrimCommandPoolKHR(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags);
+#endif
+#ifdef VK_KHR_device_group_creation
+ VkResult vkEnumeratePhysicalDeviceGroupsKHR(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+ void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties);
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+ VkResult vkGetMemoryWin32HandleKHR(
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+ VkResult vkGetMemoryWin32HandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+#endif
+#ifdef VK_KHR_external_memory_fd
+ VkResult vkGetMemoryFdKHR(
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+ VkResult vkGetMemoryFdPropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+ void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+ VkResult vkImportSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+ VkResult vkGetSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+ VkResult vkImportSemaphoreFdKHR(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+ VkResult vkGetSemaphoreFdKHR(
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+#endif
+#ifdef VK_KHR_push_descriptor
+ void vkCmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites);
+ void vkCmdPushDescriptorSetWithTemplateKHR(
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData);
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+ VkResult vkCreateDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+ void vkDestroyDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator);
+ void vkUpdateDescriptorSetWithTemplateKHR(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData);
+#endif
+#ifdef VK_KHR_create_renderpass2
+ VkResult vkCreateRenderPass2KHR(
+ VkDevice device,
+ const VkRenderPassCreateInfo2KHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+ void vkCmdBeginRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
+ void vkCmdNextSubpass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo);
+ void vkCmdEndRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo);
+#endif
+#ifdef VK_KHR_shared_presentable_image
+ VkResult vkGetSwapchainStatusKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain);
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+ void vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties);
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+ VkResult vkImportFenceWin32HandleKHR(
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+ VkResult vkGetFenceWin32HandleKHR(
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_fence_fd
+ VkResult vkImportFenceFdKHR(
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+ VkResult vkGetFenceFdKHR(
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+ VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats);
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+ VkResult vkGetPhysicalDeviceDisplayProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties);
+ VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties);
+ VkResult vkGetDisplayModeProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties);
+ VkResult vkGetDisplayPlaneCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities);
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+ void vkGetImageMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ void vkGetBufferMemoryRequirements2KHR(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ void vkGetImageSparseMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+ VkResult vkCreateSamplerYcbcrConversionKHR(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion);
+ void vkDestroySamplerYcbcrConversionKHR(
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
+#endif
+#ifdef VK_KHR_bind_memory2
+ VkResult vkBindBufferMemory2KHR(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos);
+ VkResult vkBindImageMemory2KHR(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos);
+#endif
+#ifdef VK_KHR_maintenance3
+ void vkGetDescriptorSetLayoutSupportKHR(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_draw_indirect_count
+ void vkCmdDrawIndirectCountKHR(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+ void vkCmdDrawIndexedIndirectCountKHR(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+ VkResult vkGetSwapchainGrallocUsageANDROID(
+ VkDevice device,
+ VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage);
+ VkResult vkAcquireImageANDROID(
+ VkDevice device,
+ VkImage image,
+ int nativeFenceFd,
+ VkSemaphore semaphore,
+ VkFence fence);
+ VkResult vkQueueSignalReleaseImageANDROID(
+ VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image,
+ int* pNativeFenceFd);
+#endif
+#ifdef VK_EXT_debug_report
+ VkResult vkCreateDebugReportCallbackEXT(
+ VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback);
+ void vkDestroyDebugReportCallbackEXT(
+ VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator);
+ void vkDebugReportMessageEXT(
+ VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char* pLayerPrefix,
+ const char* pMessage);
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+ VkResult vkDebugMarkerSetObjectTagEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+ VkResult vkDebugMarkerSetObjectNameEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+ void vkCmdDebugMarkerBeginEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+ void vkCmdDebugMarkerEndEXT(
+ VkCommandBuffer commandBuffer);
+ void vkCmdDebugMarkerInsertEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+ void vkCmdDrawIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+ void vkCmdDrawIndexedIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+ VkResult vkGetShaderInfoAMD(
+ VkDevice device,
+ VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType,
+ size_t* pInfoSize,
+ void* pInfo);
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+ VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+ VkResult vkGetMemoryWin32HandleNV(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+ VkResult vkCreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+ void vkCmdBeginConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+ void vkCmdEndConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer);
+#endif
+#ifdef VK_NVX_device_generated_commands
+ void vkCmdProcessCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
+ void vkCmdReserveSpaceForCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
+ VkResult vkCreateIndirectCommandsLayoutNVX(
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
+ void vkDestroyIndirectCommandsLayoutNVX(
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkCreateObjectTableNVX(
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable);
+ void vkDestroyObjectTableNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkRegisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices);
+ VkResult vkUnregisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices);
+ void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits);
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+ void vkCmdSetViewportWScalingNV(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings);
+#endif
+#ifdef VK_EXT_direct_mode_display
+ VkResult vkReleaseDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display);
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+ VkResult vkAcquireXlibDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display);
+ VkResult vkGetRandROutputDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay);
+#endif
+#ifdef VK_EXT_display_surface_counter
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+#endif
+#ifdef VK_EXT_display_control
+ VkResult vkDisplayPowerControlEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+ VkResult vkRegisterDeviceEventEXT(
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ VkResult vkRegisterDisplayEventEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ VkResult vkGetSwapchainCounterEXT(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue);
+#endif
+#ifdef VK_GOOGLE_display_timing
+ VkResult vkGetRefreshCycleDurationGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+ VkResult vkGetPastPresentationTimingGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings);
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+ void vkCmdSetDiscardRectangleEXT(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles);
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+ void vkSetHdrMetadataEXT(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata);
+#endif
+#ifdef VK_MVK_ios_surface
+ VkResult vkCreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_MVK_macos_surface
+ VkResult vkCreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+ VkResult vkSetDebugUtilsObjectNameEXT(
+ VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+ VkResult vkSetDebugUtilsObjectTagEXT(
+ VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+ void vkQueueBeginDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ void vkQueueEndDebugUtilsLabelEXT(
+ VkQueue queue);
+ void vkQueueInsertDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ void vkCmdBeginDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ void vkCmdEndDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer);
+ void vkCmdInsertDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ VkResult vkCreateDebugUtilsMessengerEXT(
+ VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger);
+ void vkDestroyDebugUtilsMessengerEXT(
+ VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator);
+ void vkSubmitDebugUtilsMessageEXT(
+ VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+ VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
+ VkDevice device,
+ const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+ VkResult vkGetMemoryAndroidHardwareBufferANDROID(
+ VkDevice device,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer);
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+ void vkCmdSetSampleLocationsEXT(
+ VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
+ void vkGetPhysicalDeviceMultisamplePropertiesEXT(
+ VkPhysicalDevice physicalDevice,
+ VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties);
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+ VkResult vkCreateValidationCacheEXT(
+ VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache);
+ void vkDestroyValidationCacheEXT(
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator);
+ VkResult vkMergeValidationCachesEXT(
+ VkDevice device,
+ VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches);
+ VkResult vkGetValidationCacheDataEXT(
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize,
+ void* pData);
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+ VkResult vkGetMemoryHostPointerPropertiesEXT(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+#endif
+#ifdef VK_AMD_buffer_marker
+ void vkCmdWriteBufferMarkerAMD(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ uint32_t marker);
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+ void vkCmdSetCheckpointNV(
+ VkCommandBuffer commandBuffer,
+ const void* pCheckpointMarker);
+ void vkGetQueueCheckpointDataNV(
+ VkQueue queue,
+ uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData);
+#endif
+
+private:
+ class Impl;
+ std::unique_ptr<Impl> mImpl;
+};
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEventHandler.cpp b/system/vulkan_enc/VkEventHandler.cpp
new file mode 100644
index 0000000..0e166f3
--- /dev/null
+++ b/system/vulkan_enc/VkEventHandler.cpp
@@ -0,0 +1,3155 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module VkEventHandler
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "VkEventHandler.h"
+
+
+#include "VkEncoder.h"
+
+
+namespace goldfish_vk {
+
+
+VkEventHandler::VkEventHandler() { }
+VkEventHandler::~VkEventHandler() { }
+#ifdef VK_VERSION_1_0
+VkResult VkEventHandler::on_vkCreateInstance(
+ void*,
+ VkResult,
+ const VkInstanceCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkInstance*)
+{
+ VkResult on_vkCreateInstance_VkResult_return = (VkResult)0;
+ return on_vkCreateInstance_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyInstance(
+ void*,
+ VkInstance,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkEnumeratePhysicalDevices(
+ void*,
+ VkResult,
+ VkInstance,
+ uint32_t*,
+ VkPhysicalDevice*)
+{
+ VkResult on_vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
+ return on_vkEnumeratePhysicalDevices_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceFeatures*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties(
+ void*,
+ VkPhysicalDevice,
+ VkFormat,
+ VkFormatProperties*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkFormat,
+ VkImageType,
+ VkImageTiling,
+ VkImageUsageFlags,
+ VkImageCreateFlags,
+ VkImageFormatProperties*)
+{
+ VkResult on_vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties(
+ void*,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkQueueFamilyProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceMemoryProperties*)
+{
+}
+PFN_vkVoidFunction VkEventHandler::on_vkGetInstanceProcAddr(
+ void*,
+ PFN_vkVoidFunction,
+ VkInstance,
+ const char*)
+{
+ PFN_vkVoidFunction on_vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ return on_vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
+}
+PFN_vkVoidFunction VkEventHandler::on_vkGetDeviceProcAddr(
+ void*,
+ PFN_vkVoidFunction,
+ VkDevice,
+ const char*)
+{
+ PFN_vkVoidFunction on_vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ return on_vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
+}
+VkResult VkEventHandler::on_vkCreateDevice(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkDeviceCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDevice*)
+{
+ VkResult on_vkCreateDevice_VkResult_return = (VkResult)0;
+ return on_vkCreateDevice_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDevice(
+ void*,
+ VkDevice,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkEnumerateInstanceExtensionProperties(
+ void*,
+ VkResult,
+ const char*,
+ uint32_t*,
+ VkExtensionProperties*)
+{
+ VkResult on_vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
+ return on_vkEnumerateInstanceExtensionProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateDeviceExtensionProperties(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const char*,
+ uint32_t*,
+ VkExtensionProperties*)
+{
+ VkResult on_vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
+ return on_vkEnumerateDeviceExtensionProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateInstanceLayerProperties(
+ void*,
+ VkResult,
+ uint32_t*,
+ VkLayerProperties*)
+{
+ VkResult on_vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+ return on_vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateDeviceLayerProperties(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkLayerProperties*)
+{
+ VkResult on_vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
+ return on_vkEnumerateDeviceLayerProperties_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceQueue(
+ void*,
+ VkDevice,
+ uint32_t,
+ uint32_t,
+ VkQueue*)
+{
+}
+VkResult VkEventHandler::on_vkQueueSubmit(
+ void*,
+ VkResult,
+ VkQueue,
+ uint32_t,
+ const VkSubmitInfo*,
+ VkFence)
+{
+ VkResult on_vkQueueSubmit_VkResult_return = (VkResult)0;
+ return on_vkQueueSubmit_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueueWaitIdle(
+ void*,
+ VkResult,
+ VkQueue)
+{
+ VkResult on_vkQueueWaitIdle_VkResult_return = (VkResult)0;
+ return on_vkQueueWaitIdle_VkResult_return;
+}
+VkResult VkEventHandler::on_vkDeviceWaitIdle(
+ void*,
+ VkResult,
+ VkDevice)
+{
+ VkResult on_vkDeviceWaitIdle_VkResult_return = (VkResult)0;
+ return on_vkDeviceWaitIdle_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateMemory(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkMemoryAllocateInfo*,
+ const VkAllocationCallbacks*,
+ VkDeviceMemory*)
+{
+ VkResult on_vkAllocateMemory_VkResult_return = (VkResult)0;
+ return on_vkAllocateMemory_VkResult_return;
+}
+void VkEventHandler::on_vkFreeMemory(
+ void*,
+ VkDevice,
+ VkDeviceMemory,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkMapMemory(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDeviceMemory,
+ VkDeviceSize,
+ VkDeviceSize,
+ VkMemoryMapFlags,
+ void**)
+{
+ VkResult on_vkMapMemory_VkResult_return = (VkResult)0;
+ return on_vkMapMemory_VkResult_return;
+}
+void VkEventHandler::on_vkUnmapMemory(
+ void*,
+ VkDevice,
+ VkDeviceMemory)
+{
+}
+VkResult VkEventHandler::on_vkFlushMappedMemoryRanges(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkMappedMemoryRange*)
+{
+ VkResult on_vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
+ return on_vkFlushMappedMemoryRanges_VkResult_return;
+}
+VkResult VkEventHandler::on_vkInvalidateMappedMemoryRanges(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkMappedMemoryRange*)
+{
+ VkResult on_vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
+ return on_vkInvalidateMappedMemoryRanges_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceMemoryCommitment(
+ void*,
+ VkDevice,
+ VkDeviceMemory,
+ VkDeviceSize*)
+{
+}
+VkResult VkEventHandler::on_vkBindBufferMemory(
+ void*,
+ VkResult,
+ VkDevice,
+ VkBuffer,
+ VkDeviceMemory,
+ VkDeviceSize)
+{
+ VkResult on_vkBindBufferMemory_VkResult_return = (VkResult)0;
+ return on_vkBindBufferMemory_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory(
+ void*,
+ VkResult,
+ VkDevice,
+ VkImage,
+ VkDeviceMemory,
+ VkDeviceSize)
+{
+ VkResult on_vkBindImageMemory_VkResult_return = (VkResult)0;
+ return on_vkBindImageMemory_VkResult_return;
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements(
+ void*,
+ VkDevice,
+ VkBuffer,
+ VkMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetImageMemoryRequirements(
+ void*,
+ VkDevice,
+ VkImage,
+ VkMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements(
+ void*,
+ VkDevice,
+ VkImage,
+ uint32_t*,
+ VkSparseImageMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties(
+ void*,
+ VkPhysicalDevice,
+ VkFormat,
+ VkImageType,
+ VkSampleCountFlagBits,
+ VkImageUsageFlags,
+ VkImageTiling,
+ uint32_t*,
+ VkSparseImageFormatProperties*)
+{
+}
+VkResult VkEventHandler::on_vkQueueBindSparse(
+ void*,
+ VkResult,
+ VkQueue,
+ uint32_t,
+ const VkBindSparseInfo*,
+ VkFence)
+{
+ VkResult on_vkQueueBindSparse_VkResult_return = (VkResult)0;
+ return on_vkQueueBindSparse_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateFence(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkFenceCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkFence*)
+{
+ VkResult on_vkCreateFence_VkResult_return = (VkResult)0;
+ return on_vkCreateFence_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyFence(
+ void*,
+ VkDevice,
+ VkFence,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetFences(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkFence*)
+{
+ VkResult on_vkResetFences_VkResult_return = (VkResult)0;
+ return on_vkResetFences_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceStatus(
+ void*,
+ VkResult,
+ VkDevice,
+ VkFence)
+{
+ VkResult on_vkGetFenceStatus_VkResult_return = (VkResult)0;
+ return on_vkGetFenceStatus_VkResult_return;
+}
+VkResult VkEventHandler::on_vkWaitForFences(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkFence*,
+ VkBool32,
+ uint64_t)
+{
+ VkResult on_vkWaitForFences_VkResult_return = (VkResult)0;
+ return on_vkWaitForFences_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateSemaphore(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSemaphoreCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkSemaphore*)
+{
+ VkResult on_vkCreateSemaphore_VkResult_return = (VkResult)0;
+ return on_vkCreateSemaphore_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySemaphore(
+ void*,
+ VkDevice,
+ VkSemaphore,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateEvent(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkEventCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkEvent*)
+{
+ VkResult on_vkCreateEvent_VkResult_return = (VkResult)0;
+ return on_vkCreateEvent_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyEvent(
+ void*,
+ VkDevice,
+ VkEvent,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetEventStatus(
+ void*,
+ VkResult,
+ VkDevice,
+ VkEvent)
+{
+ VkResult on_vkGetEventStatus_VkResult_return = (VkResult)0;
+ return on_vkGetEventStatus_VkResult_return;
+}
+VkResult VkEventHandler::on_vkSetEvent(
+ void*,
+ VkResult,
+ VkDevice,
+ VkEvent)
+{
+ VkResult on_vkSetEvent_VkResult_return = (VkResult)0;
+ return on_vkSetEvent_VkResult_return;
+}
+VkResult VkEventHandler::on_vkResetEvent(
+ void*,
+ VkResult,
+ VkDevice,
+ VkEvent)
+{
+ VkResult on_vkResetEvent_VkResult_return = (VkResult)0;
+ return on_vkResetEvent_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateQueryPool(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkQueryPoolCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkQueryPool*)
+{
+ VkResult on_vkCreateQueryPool_VkResult_return = (VkResult)0;
+ return on_vkCreateQueryPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyQueryPool(
+ void*,
+ VkDevice,
+ VkQueryPool,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetQueryPoolResults(
+ void*,
+ VkResult,
+ VkDevice,
+ VkQueryPool,
+ uint32_t,
+ uint32_t,
+ size_t,
+ void*,
+ VkDeviceSize,
+ VkQueryResultFlags)
+{
+ VkResult on_vkGetQueryPoolResults_VkResult_return = (VkResult)0;
+ return on_vkGetQueryPoolResults_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateBuffer(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkBufferCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkBuffer*)
+{
+ VkResult on_vkCreateBuffer_VkResult_return = (VkResult)0;
+ return on_vkCreateBuffer_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyBuffer(
+ void*,
+ VkDevice,
+ VkBuffer,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateBufferView(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkBufferViewCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkBufferView*)
+{
+ VkResult on_vkCreateBufferView_VkResult_return = (VkResult)0;
+ return on_vkCreateBufferView_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyBufferView(
+ void*,
+ VkDevice,
+ VkBufferView,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateImage(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImageCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkImage*)
+{
+ VkResult on_vkCreateImage_VkResult_return = (VkResult)0;
+ return on_vkCreateImage_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyImage(
+ void*,
+ VkDevice,
+ VkImage,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkGetImageSubresourceLayout(
+ void*,
+ VkDevice,
+ VkImage,
+ const VkImageSubresource*,
+ VkSubresourceLayout*)
+{
+}
+VkResult VkEventHandler::on_vkCreateImageView(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImageViewCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkImageView*)
+{
+ VkResult on_vkCreateImageView_VkResult_return = (VkResult)0;
+ return on_vkCreateImageView_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyImageView(
+ void*,
+ VkDevice,
+ VkImageView,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateShaderModule(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkShaderModuleCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkShaderModule*)
+{
+ VkResult on_vkCreateShaderModule_VkResult_return = (VkResult)0;
+ return on_vkCreateShaderModule_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyShaderModule(
+ void*,
+ VkDevice,
+ VkShaderModule,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreatePipelineCache(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkPipelineCacheCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkPipelineCache*)
+{
+ VkResult on_vkCreatePipelineCache_VkResult_return = (VkResult)0;
+ return on_vkCreatePipelineCache_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipelineCache(
+ void*,
+ VkDevice,
+ VkPipelineCache,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetPipelineCacheData(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipelineCache,
+ size_t*,
+ void*)
+{
+ VkResult on_vkGetPipelineCacheData_VkResult_return = (VkResult)0;
+ return on_vkGetPipelineCacheData_VkResult_return;
+}
+VkResult VkEventHandler::on_vkMergePipelineCaches(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipelineCache,
+ uint32_t,
+ const VkPipelineCache*)
+{
+ VkResult on_vkMergePipelineCaches_VkResult_return = (VkResult)0;
+ return on_vkMergePipelineCaches_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateGraphicsPipelines(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipelineCache,
+ uint32_t,
+ const VkGraphicsPipelineCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkPipeline*)
+{
+ VkResult on_vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
+ return on_vkCreateGraphicsPipelines_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateComputePipelines(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipelineCache,
+ uint32_t,
+ const VkComputePipelineCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkPipeline*)
+{
+ VkResult on_vkCreateComputePipelines_VkResult_return = (VkResult)0;
+ return on_vkCreateComputePipelines_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipeline(
+ void*,
+ VkDevice,
+ VkPipeline,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreatePipelineLayout(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkPipelineLayoutCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkPipelineLayout*)
+{
+ VkResult on_vkCreatePipelineLayout_VkResult_return = (VkResult)0;
+ return on_vkCreatePipelineLayout_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipelineLayout(
+ void*,
+ VkDevice,
+ VkPipelineLayout,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateSampler(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSamplerCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkSampler*)
+{
+ VkResult on_vkCreateSampler_VkResult_return = (VkResult)0;
+ return on_vkCreateSampler_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySampler(
+ void*,
+ VkDevice,
+ VkSampler,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorSetLayout(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorSetLayoutCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDescriptorSetLayout*)
+{
+ VkResult on_vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
+ return on_vkCreateDescriptorSetLayout_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorSetLayout(
+ void*,
+ VkDevice,
+ VkDescriptorSetLayout,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorPool(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorPoolCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDescriptorPool*)
+{
+ VkResult on_vkCreateDescriptorPool_VkResult_return = (VkResult)0;
+ return on_vkCreateDescriptorPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorPool(
+ void*,
+ VkDevice,
+ VkDescriptorPool,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetDescriptorPool(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDescriptorPool,
+ VkDescriptorPoolResetFlags)
+{
+ VkResult on_vkResetDescriptorPool_VkResult_return = (VkResult)0;
+ return on_vkResetDescriptorPool_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateDescriptorSets(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorSetAllocateInfo*,
+ VkDescriptorSet*)
+{
+ VkResult on_vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
+ return on_vkAllocateDescriptorSets_VkResult_return;
+}
+VkResult VkEventHandler::on_vkFreeDescriptorSets(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDescriptorPool,
+ uint32_t,
+ const VkDescriptorSet*)
+{
+ VkResult on_vkFreeDescriptorSets_VkResult_return = (VkResult)0;
+ return on_vkFreeDescriptorSets_VkResult_return;
+}
+void VkEventHandler::on_vkUpdateDescriptorSets(
+ void*,
+ VkDevice,
+ uint32_t,
+ const VkWriteDescriptorSet*,
+ uint32_t,
+ const VkCopyDescriptorSet*)
+{
+}
+VkResult VkEventHandler::on_vkCreateFramebuffer(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkFramebufferCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkFramebuffer*)
+{
+ VkResult on_vkCreateFramebuffer_VkResult_return = (VkResult)0;
+ return on_vkCreateFramebuffer_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyFramebuffer(
+ void*,
+ VkDevice,
+ VkFramebuffer,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateRenderPass(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkRenderPassCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkRenderPass*)
+{
+ VkResult on_vkCreateRenderPass_VkResult_return = (VkResult)0;
+ return on_vkCreateRenderPass_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyRenderPass(
+ void*,
+ VkDevice,
+ VkRenderPass,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkGetRenderAreaGranularity(
+ void*,
+ VkDevice,
+ VkRenderPass,
+ VkExtent2D*)
+{
+}
+VkResult VkEventHandler::on_vkCreateCommandPool(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkCommandPoolCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkCommandPool*)
+{
+ VkResult on_vkCreateCommandPool_VkResult_return = (VkResult)0;
+ return on_vkCreateCommandPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyCommandPool(
+ void*,
+ VkDevice,
+ VkCommandPool,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetCommandPool(
+ void*,
+ VkResult,
+ VkDevice,
+ VkCommandPool,
+ VkCommandPoolResetFlags)
+{
+ VkResult on_vkResetCommandPool_VkResult_return = (VkResult)0;
+ return on_vkResetCommandPool_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateCommandBuffers(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkCommandBufferAllocateInfo*,
+ VkCommandBuffer*)
+{
+ VkResult on_vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
+ return on_vkAllocateCommandBuffers_VkResult_return;
+}
+void VkEventHandler::on_vkFreeCommandBuffers(
+ void*,
+ VkDevice,
+ VkCommandPool,
+ uint32_t,
+ const VkCommandBuffer*)
+{
+}
+VkResult VkEventHandler::on_vkBeginCommandBuffer(
+ void*,
+ VkResult,
+ VkCommandBuffer,
+ const VkCommandBufferBeginInfo*)
+{
+ VkResult on_vkBeginCommandBuffer_VkResult_return = (VkResult)0;
+ return on_vkBeginCommandBuffer_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEndCommandBuffer(
+ void*,
+ VkResult,
+ VkCommandBuffer)
+{
+ VkResult on_vkEndCommandBuffer_VkResult_return = (VkResult)0;
+ return on_vkEndCommandBuffer_VkResult_return;
+}
+VkResult VkEventHandler::on_vkResetCommandBuffer(
+ void*,
+ VkResult,
+ VkCommandBuffer,
+ VkCommandBufferResetFlags)
+{
+ VkResult on_vkResetCommandBuffer_VkResult_return = (VkResult)0;
+ return on_vkResetCommandBuffer_VkResult_return;
+}
+void VkEventHandler::on_vkCmdBindPipeline(
+ void*,
+ VkCommandBuffer,
+ VkPipelineBindPoint,
+ VkPipeline)
+{
+}
+void VkEventHandler::on_vkCmdSetViewport(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkViewport*)
+{
+}
+void VkEventHandler::on_vkCmdSetScissor(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkRect2D*)
+{
+}
+void VkEventHandler::on_vkCmdSetLineWidth(
+ void*,
+ VkCommandBuffer,
+ float)
+{
+}
+void VkEventHandler::on_vkCmdSetDepthBias(
+ void*,
+ VkCommandBuffer,
+ float,
+ float,
+ float)
+{
+}
+void VkEventHandler::on_vkCmdSetBlendConstants(
+ void*,
+ VkCommandBuffer,
+ const float)
+{
+}
+void VkEventHandler::on_vkCmdSetDepthBounds(
+ void*,
+ VkCommandBuffer,
+ float,
+ float)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilCompareMask(
+ void*,
+ VkCommandBuffer,
+ VkStencilFaceFlags,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilWriteMask(
+ void*,
+ VkCommandBuffer,
+ VkStencilFaceFlags,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilReference(
+ void*,
+ VkCommandBuffer,
+ VkStencilFaceFlags,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdBindDescriptorSets(
+ void*,
+ VkCommandBuffer,
+ VkPipelineBindPoint,
+ VkPipelineLayout,
+ uint32_t,
+ uint32_t,
+ const VkDescriptorSet*,
+ uint32_t,
+ const uint32_t*)
+{
+}
+void VkEventHandler::on_vkCmdBindIndexBuffer(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkIndexType)
+{
+}
+void VkEventHandler::on_vkCmdBindVertexBuffers(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkBuffer*,
+ const VkDeviceSize*)
+{
+}
+void VkEventHandler::on_vkCmdDraw(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexed(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ int32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndirect(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirect(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatch(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchIndirect(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize)
+{
+}
+void VkEventHandler::on_vkCmdCopyBuffer(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkBuffer,
+ uint32_t,
+ const VkBufferCopy*)
+{
+}
+void VkEventHandler::on_vkCmdCopyImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ VkImage,
+ VkImageLayout,
+ uint32_t,
+ const VkImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdBlitImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ VkImage,
+ VkImageLayout,
+ uint32_t,
+ const VkImageBlit*,
+ VkFilter)
+{
+}
+void VkEventHandler::on_vkCmdCopyBufferToImage(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkImage,
+ VkImageLayout,
+ uint32_t,
+ const VkBufferImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdCopyImageToBuffer(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ VkBuffer,
+ uint32_t,
+ const VkBufferImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdUpdateBuffer(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkDeviceSize,
+ const void*)
+{
+}
+void VkEventHandler::on_vkCmdFillBuffer(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkDeviceSize,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdClearColorImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ const VkClearColorValue*,
+ uint32_t,
+ const VkImageSubresourceRange*)
+{
+}
+void VkEventHandler::on_vkCmdClearDepthStencilImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ const VkClearDepthStencilValue*,
+ uint32_t,
+ const VkImageSubresourceRange*)
+{
+}
+void VkEventHandler::on_vkCmdClearAttachments(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ const VkClearAttachment*,
+ uint32_t,
+ const VkClearRect*)
+{
+}
+void VkEventHandler::on_vkCmdResolveImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ VkImage,
+ VkImageLayout,
+ uint32_t,
+ const VkImageResolve*)
+{
+}
+void VkEventHandler::on_vkCmdSetEvent(
+ void*,
+ VkCommandBuffer,
+ VkEvent,
+ VkPipelineStageFlags)
+{
+}
+void VkEventHandler::on_vkCmdResetEvent(
+ void*,
+ VkCommandBuffer,
+ VkEvent,
+ VkPipelineStageFlags)
+{
+}
+void VkEventHandler::on_vkCmdWaitEvents(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ const VkEvent*,
+ VkPipelineStageFlags,
+ VkPipelineStageFlags,
+ uint32_t,
+ const VkMemoryBarrier*,
+ uint32_t,
+ const VkBufferMemoryBarrier*,
+ uint32_t,
+ const VkImageMemoryBarrier*)
+{
+}
+void VkEventHandler::on_vkCmdPipelineBarrier(
+ void*,
+ VkCommandBuffer,
+ VkPipelineStageFlags,
+ VkPipelineStageFlags,
+ VkDependencyFlags,
+ uint32_t,
+ const VkMemoryBarrier*,
+ uint32_t,
+ const VkBufferMemoryBarrier*,
+ uint32_t,
+ const VkImageMemoryBarrier*)
+{
+}
+void VkEventHandler::on_vkCmdBeginQuery(
+ void*,
+ VkCommandBuffer,
+ VkQueryPool,
+ uint32_t,
+ VkQueryControlFlags)
+{
+}
+void VkEventHandler::on_vkCmdEndQuery(
+ void*,
+ VkCommandBuffer,
+ VkQueryPool,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdResetQueryPool(
+ void*,
+ VkCommandBuffer,
+ VkQueryPool,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdWriteTimestamp(
+ void*,
+ VkCommandBuffer,
+ VkPipelineStageFlagBits,
+ VkQueryPool,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdCopyQueryPoolResults(
+ void*,
+ VkCommandBuffer,
+ VkQueryPool,
+ uint32_t,
+ uint32_t,
+ VkBuffer,
+ VkDeviceSize,
+ VkDeviceSize,
+ VkQueryResultFlags)
+{
+}
+void VkEventHandler::on_vkCmdPushConstants(
+ void*,
+ VkCommandBuffer,
+ VkPipelineLayout,
+ VkShaderStageFlags,
+ uint32_t,
+ uint32_t,
+ const void*)
+{
+}
+void VkEventHandler::on_vkCmdBeginRenderPass(
+ void*,
+ VkCommandBuffer,
+ const VkRenderPassBeginInfo*,
+ VkSubpassContents)
+{
+}
+void VkEventHandler::on_vkCmdNextSubpass(
+ void*,
+ VkCommandBuffer,
+ VkSubpassContents)
+{
+}
+void VkEventHandler::on_vkCmdEndRenderPass(
+ void*,
+ VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdExecuteCommands(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ const VkCommandBuffer*)
+{
+}
+#endif
+#ifdef VK_VERSION_1_1
+VkResult VkEventHandler::on_vkEnumerateInstanceVersion(
+ void*,
+ VkResult,
+ uint32_t*)
+{
+ VkResult on_vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+ return on_vkEnumerateInstanceVersion_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindBufferMemory2(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkBindBufferMemoryInfo*)
+{
+ VkResult on_vkBindBufferMemory2_VkResult_return = (VkResult)0;
+ return on_vkBindBufferMemory2_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory2(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkBindImageMemoryInfo*)
+{
+ VkResult on_vkBindImageMemory2_VkResult_return = (VkResult)0;
+ return on_vkBindImageMemory2_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceGroupPeerMemoryFeatures(
+ void*,
+ VkDevice,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ VkPeerMemoryFeatureFlags*)
+{
+}
+void VkEventHandler::on_vkCmdSetDeviceMask(
+ void*,
+ VkCommandBuffer,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchBase(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t)
+{
+}
+VkResult VkEventHandler::on_vkEnumeratePhysicalDeviceGroups(
+ void*,
+ VkResult,
+ VkInstance,
+ uint32_t*,
+ VkPhysicalDeviceGroupProperties*)
+{
+ VkResult on_vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
+ return on_vkEnumeratePhysicalDeviceGroups_VkResult_return;
+}
+void VkEventHandler::on_vkGetImageMemoryRequirements2(
+ void*,
+ VkDevice,
+ const VkImageMemoryRequirementsInfo2*,
+ VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements2(
+ void*,
+ VkDevice,
+ const VkBufferMemoryRequirementsInfo2*,
+ VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements2(
+ void*,
+ VkDevice,
+ const VkImageSparseMemoryRequirementsInfo2*,
+ uint32_t*,
+ VkSparseImageMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures2(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceFeatures2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties2(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties2(
+ void*,
+ VkPhysicalDevice,
+ VkFormat,
+ VkFormatProperties2*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties2(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2*,
+ VkImageFormatProperties2*)
+{
+ VkResult on_vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties2(
+ void*,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkQueueFamilyProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties2(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceMemoryProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties2(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2*,
+ uint32_t*,
+ VkSparseImageFormatProperties2*)
+{
+}
+void VkEventHandler::on_vkTrimCommandPool(
+ void*,
+ VkDevice,
+ VkCommandPool,
+ VkCommandPoolTrimFlags)
+{
+}
+void VkEventHandler::on_vkGetDeviceQueue2(
+ void*,
+ VkDevice,
+ const VkDeviceQueueInfo2*,
+ VkQueue*)
+{
+}
+VkResult VkEventHandler::on_vkCreateSamplerYcbcrConversion(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSamplerYcbcrConversionCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkSamplerYcbcrConversion*)
+{
+ VkResult on_vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
+ return on_vkCreateSamplerYcbcrConversion_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySamplerYcbcrConversion(
+ void*,
+ VkDevice,
+ VkSamplerYcbcrConversion,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorUpdateTemplate(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorUpdateTemplateCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDescriptorUpdateTemplate*)
+{
+ VkResult on_vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+ return on_vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorUpdateTemplate(
+ void*,
+ VkDevice,
+ VkDescriptorUpdateTemplate,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkUpdateDescriptorSetWithTemplate(
+ void*,
+ VkDevice,
+ VkDescriptorSet,
+ VkDescriptorUpdateTemplate,
+ const void*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalBufferProperties(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo*,
+ VkExternalBufferProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalFenceProperties(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo*,
+ VkExternalFenceProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalSemaphoreProperties(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo*,
+ VkExternalSemaphoreProperties*)
+{
+}
+void VkEventHandler::on_vkGetDescriptorSetLayoutSupport(
+ void*,
+ VkDevice,
+ const VkDescriptorSetLayoutCreateInfo*,
+ VkDescriptorSetLayoutSupport*)
+{
+}
+#endif
+#ifdef VK_KHR_surface
+void VkEventHandler::on_vkDestroySurfaceKHR(
+ void*,
+ VkInstance,
+ VkSurfaceKHR,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceSupportKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t,
+ VkSurfaceKHR,
+ VkBool32*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ VkSurfaceCapabilitiesKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceFormatsKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ uint32_t*,
+ VkSurfaceFormatKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfacePresentModesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ uint32_t*,
+ VkPresentModeKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_swapchain
+VkResult VkEventHandler::on_vkCreateSwapchainKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSwapchainCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSwapchainKHR*)
+{
+ VkResult on_vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateSwapchainKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySwapchainKHR(
+ void*,
+ VkDevice,
+ VkSwapchainKHR,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetSwapchainImagesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ uint32_t*,
+ VkImage*)
+{
+ VkResult on_vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetSwapchainImagesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireNextImageKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ uint64_t,
+ VkSemaphore,
+ VkFence,
+ uint32_t*)
+{
+ VkResult on_vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+ return on_vkAcquireNextImageKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueuePresentKHR(
+ void*,
+ VkResult,
+ VkQueue,
+ const VkPresentInfoKHR*)
+{
+ VkResult on_vkQueuePresentKHR_VkResult_return = (VkResult)0;
+ return on_vkQueuePresentKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDeviceGroupPresentCapabilitiesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDeviceGroupPresentCapabilitiesKHR*)
+{
+ VkResult on_vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDeviceGroupSurfacePresentModesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSurfaceKHR,
+ VkDeviceGroupPresentModeFlagsKHR*)
+{
+ VkResult on_vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDevicePresentRectanglesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ uint32_t*,
+ VkRect2D*)
+{
+ VkResult on_vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireNextImage2KHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkAcquireNextImageInfoKHR*,
+ uint32_t*)
+{
+ VkResult on_vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+ return on_vkAcquireNextImage2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPropertiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkDisplayPropertiesKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkDisplayPlanePropertiesKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneSupportedDisplaysKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t,
+ uint32_t*,
+ VkDisplayKHR*)
+{
+ VkResult on_vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayModePropertiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayKHR,
+ uint32_t*,
+ VkDisplayModePropertiesKHR*)
+{
+ VkResult on_vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayModePropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateDisplayModeKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayKHR,
+ const VkDisplayModeCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkDisplayModeKHR*)
+{
+ VkResult on_vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateDisplayModeKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneCapabilitiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayModeKHR,
+ uint32_t,
+ VkDisplayPlaneCapabilitiesKHR*)
+{
+ VkResult on_vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateDisplayPlaneSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkDisplaySurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display_swapchain
+VkResult VkEventHandler::on_vkCreateSharedSwapchainsKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkSwapchainCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSwapchainKHR*)
+{
+ VkResult on_vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateSharedSwapchainsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_xlib_surface
+VkResult VkEventHandler::on_vkCreateXlibSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkXlibSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateXlibSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t,
+ Display*,
+ VisualID)
+{
+ VkBool32 on_vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_xcb_surface
+VkResult VkEventHandler::on_vkCreateXcbSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkXcbSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateXcbSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t,
+ xcb_connection_t*,
+ xcb_visualid_t)
+{
+ VkBool32 on_vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_wayland_surface
+VkResult VkEventHandler::on_vkCreateWaylandSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkWaylandSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateWaylandSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t,
+ wl_display*)
+{
+ VkBool32 on_vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_mir_surface
+VkResult VkEventHandler::on_vkCreateMirSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkMirSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateMirSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceMirPresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t,
+ MirConnection*)
+{
+ VkBool32 on_vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_android_surface
+VkResult VkEventHandler::on_vkCreateAndroidSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkAndroidSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateAndroidSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_surface
+VkResult VkEventHandler::on_vkCreateWin32SurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkWin32SurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateWin32SurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t)
+{
+ VkBool32 on_vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures2KHR(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceFeatures2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ VkFormat,
+ VkFormatProperties2*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2*,
+ VkImageFormatProperties2*)
+{
+ VkResult on_vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkQueueFamilyProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceMemoryProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2*,
+ uint32_t*,
+ VkSparseImageFormatProperties2*)
+{
+}
+#endif
+#ifdef VK_KHR_device_group
+void VkEventHandler::on_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+ void*,
+ VkDevice,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ VkPeerMemoryFeatureFlags*)
+{
+}
+void VkEventHandler::on_vkCmdSetDeviceMaskKHR(
+ void*,
+ VkCommandBuffer,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchBaseKHR(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t)
+{
+}
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+void VkEventHandler::on_vkTrimCommandPoolKHR(
+ void*,
+ VkDevice,
+ VkCommandPool,
+ VkCommandPoolTrimFlags)
+{
+}
+#endif
+#ifdef VK_KHR_device_group_creation
+VkResult VkEventHandler::on_vkEnumeratePhysicalDeviceGroupsKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ uint32_t*,
+ VkPhysicalDeviceGroupProperties*)
+{
+ VkResult on_vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
+ return on_vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo*,
+ VkExternalBufferProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+VkResult VkEventHandler::on_vkGetMemoryWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkMemoryGetWin32HandleInfoKHR*,
+ HANDLE*)
+{
+ VkResult on_vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryWin32HandlePropertiesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkExternalMemoryHandleTypeFlagBits,
+ HANDLE,
+ VkMemoryWin32HandlePropertiesKHR*)
+{
+ VkResult on_vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_fd
+VkResult VkEventHandler::on_vkGetMemoryFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkMemoryGetFdInfoKHR*,
+ int*)
+{
+ VkResult on_vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryFdPropertiesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkExternalMemoryHandleTypeFlagBits,
+ int,
+ VkMemoryFdPropertiesKHR*)
+{
+ VkResult on_vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo*,
+ VkExternalSemaphoreProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+VkResult VkEventHandler::on_vkImportSemaphoreWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImportSemaphoreWin32HandleInfoKHR*)
+{
+ VkResult on_vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSemaphoreWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSemaphoreGetWin32HandleInfoKHR*,
+ HANDLE*)
+{
+ VkResult on_vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+VkResult VkEventHandler::on_vkImportSemaphoreFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImportSemaphoreFdInfoKHR*)
+{
+ VkResult on_vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ return on_vkImportSemaphoreFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSemaphoreFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSemaphoreGetFdInfoKHR*,
+ int*)
+{
+ VkResult on_vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ return on_vkGetSemaphoreFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_push_descriptor
+void VkEventHandler::on_vkCmdPushDescriptorSetKHR(
+ void*,
+ VkCommandBuffer,
+ VkPipelineBindPoint,
+ VkPipelineLayout,
+ uint32_t,
+ uint32_t,
+ const VkWriteDescriptorSet*)
+{
+}
+void VkEventHandler::on_vkCmdPushDescriptorSetWithTemplateKHR(
+ void*,
+ VkCommandBuffer,
+ VkDescriptorUpdateTemplate,
+ VkPipelineLayout,
+ uint32_t,
+ const void*)
+{
+}
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+VkResult VkEventHandler::on_vkCreateDescriptorUpdateTemplateKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorUpdateTemplateCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDescriptorUpdateTemplate*)
+{
+ VkResult on_vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorUpdateTemplateKHR(
+ void*,
+ VkDevice,
+ VkDescriptorUpdateTemplate,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkUpdateDescriptorSetWithTemplateKHR(
+ void*,
+ VkDevice,
+ VkDescriptorSet,
+ VkDescriptorUpdateTemplate,
+ const void*)
+{
+}
+#endif
+#ifdef VK_KHR_create_renderpass2
+VkResult VkEventHandler::on_vkCreateRenderPass2KHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkRenderPassCreateInfo2KHR*,
+ const VkAllocationCallbacks*,
+ VkRenderPass*)
+{
+ VkResult on_vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+ return on_vkCreateRenderPass2KHR_VkResult_return;
+}
+void VkEventHandler::on_vkCmdBeginRenderPass2KHR(
+ void*,
+ VkCommandBuffer,
+ const VkRenderPassBeginInfo*,
+ const VkSubpassBeginInfoKHR*)
+{
+}
+void VkEventHandler::on_vkCmdNextSubpass2KHR(
+ void*,
+ VkCommandBuffer,
+ const VkSubpassBeginInfoKHR*,
+ const VkSubpassEndInfoKHR*)
+{
+}
+void VkEventHandler::on_vkCmdEndRenderPass2KHR(
+ void*,
+ VkCommandBuffer,
+ const VkSubpassEndInfoKHR*)
+{
+}
+#endif
+#ifdef VK_KHR_shared_presentable_image
+VkResult VkEventHandler::on_vkGetSwapchainStatusKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR)
+{
+ VkResult on_vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+ return on_vkGetSwapchainStatusKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo*,
+ VkExternalFenceProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+VkResult VkEventHandler::on_vkImportFenceWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImportFenceWin32HandleInfoKHR*)
+{
+ VkResult on_vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkImportFenceWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkFenceGetWin32HandleInfoKHR*,
+ HANDLE*)
+{
+ VkResult on_vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkGetFenceWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_fd
+VkResult VkEventHandler::on_vkImportFenceFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImportFenceFdInfoKHR*)
+{
+ VkResult on_vkImportFenceFdKHR_VkResult_return = (VkResult)0;
+ return on_vkImportFenceFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkFenceGetFdInfoKHR*,
+ int*)
+{
+ VkResult on_vkGetFenceFdKHR_VkResult_return = (VkResult)0;
+ return on_vkGetFenceFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR*,
+ VkSurfaceCapabilities2KHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceFormats2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR*,
+ uint32_t*,
+ VkSurfaceFormat2KHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayProperties2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkDisplayProperties2KHR*)
+{
+ VkResult on_vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkDisplayPlaneProperties2KHR*)
+{
+ VkResult on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayModeProperties2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayKHR,
+ uint32_t*,
+ VkDisplayModeProperties2KHR*)
+{
+ VkResult on_vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayModeProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneCapabilities2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkDisplayPlaneInfo2KHR*,
+ VkDisplayPlaneCapabilities2KHR*)
+{
+ VkResult on_vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+void VkEventHandler::on_vkGetImageMemoryRequirements2KHR(
+ void*,
+ VkDevice,
+ const VkImageMemoryRequirementsInfo2*,
+ VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements2KHR(
+ void*,
+ VkDevice,
+ const VkBufferMemoryRequirementsInfo2*,
+ VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements2KHR(
+ void*,
+ VkDevice,
+ const VkImageSparseMemoryRequirementsInfo2*,
+ uint32_t*,
+ VkSparseImageMemoryRequirements2*)
+{
+}
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+VkResult VkEventHandler::on_vkCreateSamplerYcbcrConversionKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSamplerYcbcrConversionCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkSamplerYcbcrConversion*)
+{
+ VkResult on_vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateSamplerYcbcrConversionKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySamplerYcbcrConversionKHR(
+ void*,
+ VkDevice,
+ VkSamplerYcbcrConversion,
+ const VkAllocationCallbacks*)
+{
+}
+#endif
+#ifdef VK_KHR_bind_memory2
+VkResult VkEventHandler::on_vkBindBufferMemory2KHR(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkBindBufferMemoryInfo*)
+{
+ VkResult on_vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
+ return on_vkBindBufferMemory2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory2KHR(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkBindImageMemoryInfo*)
+{
+ VkResult on_vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
+ return on_vkBindImageMemory2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance3
+void VkEventHandler::on_vkGetDescriptorSetLayoutSupportKHR(
+ void*,
+ VkDevice,
+ const VkDescriptorSetLayoutCreateInfo*,
+ VkDescriptorSetLayoutSupport*)
+{
+}
+#endif
+#ifdef VK_KHR_draw_indirect_count
+void VkEventHandler::on_vkCmdDrawIndirectCountKHR(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirectCountKHR(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+VkResult VkEventHandler::on_vkGetSwapchainGrallocUsageANDROID(
+ void*,
+ VkResult,
+ VkDevice,
+ VkFormat,
+ VkImageUsageFlags,
+ int*)
+{
+ VkResult on_vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
+ return on_vkGetSwapchainGrallocUsageANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireImageANDROID(
+ void*,
+ VkResult,
+ VkDevice,
+ VkImage,
+ int,
+ VkSemaphore,
+ VkFence)
+{
+ VkResult on_vkAcquireImageANDROID_VkResult_return = (VkResult)0;
+ return on_vkAcquireImageANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueueSignalReleaseImageANDROID(
+ void*,
+ VkResult,
+ VkQueue,
+ uint32_t,
+ const VkSemaphore*,
+ VkImage,
+ int*)
+{
+ VkResult on_vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
+ return on_vkQueueSignalReleaseImageANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_debug_report
+VkResult VkEventHandler::on_vkCreateDebugReportCallbackEXT(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkDebugReportCallbackCreateInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkDebugReportCallbackEXT*)
+{
+ VkResult on_vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
+ return on_vkCreateDebugReportCallbackEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDebugReportCallbackEXT(
+ void*,
+ VkInstance,
+ VkDebugReportCallbackEXT,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkDebugReportMessageEXT(
+ void*,
+ VkInstance,
+ VkDebugReportFlagsEXT,
+ VkDebugReportObjectTypeEXT,
+ uint64_t,
+ size_t,
+ int32_t,
+ const char*,
+ const char*)
+{
+}
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+VkResult VkEventHandler::on_vkDebugMarkerSetObjectTagEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDebugMarkerObjectTagInfoEXT*)
+{
+ VkResult on_vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+ return on_vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkDebugMarkerSetObjectNameEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDebugMarkerObjectNameInfoEXT*)
+{
+ VkResult on_vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+ return on_vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
+void VkEventHandler::on_vkCmdDebugMarkerBeginEXT(
+ void*,
+ VkCommandBuffer,
+ const VkDebugMarkerMarkerInfoEXT*)
+{
+}
+void VkEventHandler::on_vkCmdDebugMarkerEndEXT(
+ void*,
+ VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdDebugMarkerInsertEXT(
+ void*,
+ VkCommandBuffer,
+ const VkDebugMarkerMarkerInfoEXT*)
+{
+}
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+void VkEventHandler::on_vkCmdDrawIndirectCountAMD(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirectCountAMD(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+VkResult VkEventHandler::on_vkGetShaderInfoAMD(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipeline,
+ VkShaderStageFlagBits,
+ VkShaderInfoTypeAMD,
+ size_t*,
+ void*)
+{
+ VkResult on_vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+ return on_vkGetShaderInfoAMD_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+VkResult VkEventHandler::on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkFormat,
+ VkImageType,
+ VkImageTiling,
+ VkImageUsageFlags,
+ VkImageCreateFlags,
+ VkExternalMemoryHandleTypeFlagsNV,
+ VkExternalImageFormatPropertiesNV*)
+{
+ VkResult on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+VkResult VkEventHandler::on_vkGetMemoryWin32HandleNV(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDeviceMemory,
+ VkExternalMemoryHandleTypeFlagsNV,
+ HANDLE*)
+{
+ VkResult on_vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryWin32HandleNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+VkResult VkEventHandler::on_vkCreateViSurfaceNN(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkViSurfaceCreateInfoNN*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
+ return on_vkCreateViSurfaceNN_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void VkEventHandler::on_vkCmdBeginConditionalRenderingEXT(
+ void*,
+ VkCommandBuffer,
+ const VkConditionalRenderingBeginInfoEXT*)
+{
+}
+void VkEventHandler::on_vkCmdEndConditionalRenderingEXT(
+ void*,
+ VkCommandBuffer)
+{
+}
+#endif
+#ifdef VK_NVX_device_generated_commands
+void VkEventHandler::on_vkCmdProcessCommandsNVX(
+ void*,
+ VkCommandBuffer,
+ const VkCmdProcessCommandsInfoNVX*)
+{
+}
+void VkEventHandler::on_vkCmdReserveSpaceForCommandsNVX(
+ void*,
+ VkCommandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX*)
+{
+}
+VkResult VkEventHandler::on_vkCreateIndirectCommandsLayoutNVX(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkIndirectCommandsLayoutCreateInfoNVX*,
+ const VkAllocationCallbacks*,
+ VkIndirectCommandsLayoutNVX*)
+{
+ VkResult on_vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+ return on_vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyIndirectCommandsLayoutNVX(
+ void*,
+ VkDevice,
+ VkIndirectCommandsLayoutNVX,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateObjectTableNVX(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkObjectTableCreateInfoNVX*,
+ const VkAllocationCallbacks*,
+ VkObjectTableNVX*)
+{
+ VkResult on_vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+ return on_vkCreateObjectTableNVX_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyObjectTableNVX(
+ void*,
+ VkDevice,
+ VkObjectTableNVX,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkRegisterObjectsNVX(
+ void*,
+ VkResult,
+ VkDevice,
+ VkObjectTableNVX,
+ uint32_t,
+ const VkObjectTableEntryNVX* const*,
+ const uint32_t*)
+{
+ VkResult on_vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+ return on_vkRegisterObjectsNVX_VkResult_return;
+}
+VkResult VkEventHandler::on_vkUnregisterObjectsNVX(
+ void*,
+ VkResult,
+ VkDevice,
+ VkObjectTableNVX,
+ uint32_t,
+ const VkObjectEntryTypeNVX*,
+ const uint32_t*)
+{
+ VkResult on_vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+ return on_vkUnregisterObjectsNVX_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ void*,
+ VkPhysicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX*,
+ VkDeviceGeneratedCommandsLimitsNVX*)
+{
+}
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void VkEventHandler::on_vkCmdSetViewportWScalingNV(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkViewportWScalingNV*)
+{
+}
+#endif
+#ifdef VK_EXT_direct_mode_display
+VkResult VkEventHandler::on_vkReleaseDisplayEXT(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayKHR)
+{
+ VkResult on_vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
+ return on_vkReleaseDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+VkResult VkEventHandler::on_vkAcquireXlibDisplayEXT(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ Display*,
+ VkDisplayKHR)
+{
+ VkResult on_vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
+ return on_vkAcquireXlibDisplayEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetRandROutputDisplayEXT(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ Display*,
+ RROutput,
+ VkDisplayKHR*)
+{
+ VkResult on_vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
+ return on_vkGetRandROutputDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_surface_counter
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ VkSurfaceCapabilities2EXT*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_control
+VkResult VkEventHandler::on_vkDisplayPowerControlEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDisplayKHR,
+ const VkDisplayPowerInfoEXT*)
+{
+ VkResult on_vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+ return on_vkDisplayPowerControlEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkRegisterDeviceEventEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDeviceEventInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkFence*)
+{
+ VkResult on_vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+ return on_vkRegisterDeviceEventEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkRegisterDisplayEventEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDisplayKHR,
+ const VkDisplayEventInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkFence*)
+{
+ VkResult on_vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+ return on_vkRegisterDisplayEventEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSwapchainCounterEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ VkSurfaceCounterFlagBitsEXT,
+ uint64_t*)
+{
+ VkResult on_vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+ return on_vkGetSwapchainCounterEXT_VkResult_return;
+}
+#endif
+#ifdef VK_GOOGLE_display_timing
+VkResult VkEventHandler::on_vkGetRefreshCycleDurationGOOGLE(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ VkRefreshCycleDurationGOOGLE*)
+{
+ VkResult on_vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+ return on_vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPastPresentationTimingGOOGLE(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ uint32_t*,
+ VkPastPresentationTimingGOOGLE*)
+{
+ VkResult on_vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+ return on_vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+void VkEventHandler::on_vkCmdSetDiscardRectangleEXT(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkRect2D*)
+{
+}
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void VkEventHandler::on_vkSetHdrMetadataEXT(
+ void*,
+ VkDevice,
+ uint32_t,
+ const VkSwapchainKHR*,
+ const VkHdrMetadataEXT*)
+{
+}
+#endif
+#ifdef VK_MVK_ios_surface
+VkResult VkEventHandler::on_vkCreateIOSSurfaceMVK(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkIOSSurfaceCreateInfoMVK*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
+ return on_vkCreateIOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_MVK_macos_surface
+VkResult VkEventHandler::on_vkCreateMacOSSurfaceMVK(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkMacOSSurfaceCreateInfoMVK*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
+ return on_vkCreateMacOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+VkResult VkEventHandler::on_vkSetDebugUtilsObjectNameEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDebugUtilsObjectNameInfoEXT*)
+{
+ VkResult on_vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+ return on_vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkSetDebugUtilsObjectTagEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDebugUtilsObjectTagInfoEXT*)
+{
+ VkResult on_vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+ return on_vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
+void VkEventHandler::on_vkQueueBeginDebugUtilsLabelEXT(
+ void*,
+ VkQueue,
+ const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkQueueEndDebugUtilsLabelEXT(
+ void*,
+ VkQueue)
+{
+}
+void VkEventHandler::on_vkQueueInsertDebugUtilsLabelEXT(
+ void*,
+ VkQueue,
+ const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkCmdBeginDebugUtilsLabelEXT(
+ void*,
+ VkCommandBuffer,
+ const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkCmdEndDebugUtilsLabelEXT(
+ void*,
+ VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdInsertDebugUtilsLabelEXT(
+ void*,
+ VkCommandBuffer,
+ const VkDebugUtilsLabelEXT*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDebugUtilsMessengerEXT(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkDebugUtilsMessengerCreateInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkDebugUtilsMessengerEXT*)
+{
+ VkResult on_vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+ return on_vkCreateDebugUtilsMessengerEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDebugUtilsMessengerEXT(
+ void*,
+ VkInstance,
+ VkDebugUtilsMessengerEXT,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkSubmitDebugUtilsMessageEXT(
+ void*,
+ VkInstance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT,
+ VkDebugUtilsMessageTypeFlagsEXT,
+ const VkDebugUtilsMessengerCallbackDataEXT*)
+{
+}
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+VkResult VkEventHandler::on_vkGetAndroidHardwareBufferPropertiesANDROID(
+ void*,
+ VkResult,
+ VkDevice,
+ const AHardwareBuffer*,
+ VkAndroidHardwareBufferPropertiesANDROID*)
+{
+ VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
+ return on_vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryAndroidHardwareBufferANDROID(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID*,
+ AHardwareBuffer**)
+{
+ VkResult on_vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void VkEventHandler::on_vkCmdSetSampleLocationsEXT(
+ void*,
+ VkCommandBuffer,
+ const VkSampleLocationsInfoEXT*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+ void*,
+ VkPhysicalDevice,
+ VkSampleCountFlagBits,
+ VkMultisamplePropertiesEXT*)
+{
+}
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+VkResult VkEventHandler::on_vkCreateValidationCacheEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkValidationCacheCreateInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkValidationCacheEXT*)
+{
+ VkResult on_vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+ return on_vkCreateValidationCacheEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyValidationCacheEXT(
+ void*,
+ VkDevice,
+ VkValidationCacheEXT,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkMergeValidationCachesEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkValidationCacheEXT,
+ uint32_t,
+ const VkValidationCacheEXT*)
+{
+ VkResult on_vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+ return on_vkMergeValidationCachesEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetValidationCacheDataEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkValidationCacheEXT,
+ size_t*,
+ void*)
+{
+ VkResult on_vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+ return on_vkGetValidationCacheDataEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+VkResult VkEventHandler::on_vkGetMemoryHostPointerPropertiesEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkExternalMemoryHandleTypeFlagBits,
+ const void*,
+ VkMemoryHostPointerPropertiesEXT*)
+{
+ VkResult on_vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_buffer_marker
+void VkEventHandler::on_vkCmdWriteBufferMarkerAMD(
+ void*,
+ VkCommandBuffer,
+ VkPipelineStageFlagBits,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t)
+{
+}
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void VkEventHandler::on_vkCmdSetCheckpointNV(
+ void*,
+ VkCommandBuffer,
+ const void*)
+{
+}
+void VkEventHandler::on_vkGetQueueCheckpointDataNV(
+ void*,
+ VkQueue,
+ uint32_t*,
+ VkCheckpointDataNV*)
+{
+}
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEventHandler.h b/system/vulkan_enc/VkEventHandler.h
new file mode 100644
index 0000000..fcc4192
--- /dev/null
+++ b/system/vulkan_enc/VkEventHandler.h
@@ -0,0 +1,2218 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module VkEventHandler
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+
+class VkEncoder;
+class VkEventHandler {
+public:
+ VkEventHandler();
+ virtual ~VkEventHandler();
+#ifdef VK_VERSION_1_0
+ virtual VkResult on_vkCreateInstance(
+ void* context,
+ VkResult input_result,
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+ virtual void on_vkDestroyInstance(
+ void* context,
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkEnumeratePhysicalDevices(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices);
+ virtual void on_vkGetPhysicalDeviceFeatures(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures);
+ virtual void on_vkGetPhysicalDeviceFormatProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties);
+ virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties);
+ virtual void on_vkGetPhysicalDeviceProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties);
+ virtual void on_vkGetPhysicalDeviceQueueFamilyProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties);
+ virtual void on_vkGetPhysicalDeviceMemoryProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ virtual PFN_vkVoidFunction on_vkGetInstanceProcAddr(
+ void* context,
+ PFN_vkVoidFunction input_result,
+ VkInstance instance,
+ const char* pName);
+ virtual PFN_vkVoidFunction on_vkGetDeviceProcAddr(
+ void* context,
+ PFN_vkVoidFunction input_result,
+ VkDevice device,
+ const char* pName);
+ virtual VkResult on_vkCreateDevice(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+ virtual void on_vkDestroyDevice(
+ void* context,
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkEnumerateInstanceExtensionProperties(
+ void* context,
+ VkResult input_result,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+ virtual VkResult on_vkEnumerateDeviceExtensionProperties(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+ virtual VkResult on_vkEnumerateInstanceLayerProperties(
+ void* context,
+ VkResult input_result,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+ virtual VkResult on_vkEnumerateDeviceLayerProperties(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+ virtual void on_vkGetDeviceQueue(
+ void* context,
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue);
+ virtual VkResult on_vkQueueSubmit(
+ void* context,
+ VkResult input_result,
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence);
+ virtual VkResult on_vkQueueWaitIdle(
+ void* context,
+ VkResult input_result,
+ VkQueue queue);
+ virtual VkResult on_vkDeviceWaitIdle(
+ void* context,
+ VkResult input_result,
+ VkDevice device);
+ virtual VkResult on_vkAllocateMemory(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory);
+ virtual void on_vkFreeMemory(
+ void* context,
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkMapMemory(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData);
+ virtual void on_vkUnmapMemory(
+ void* context,
+ VkDevice device,
+ VkDeviceMemory memory);
+ virtual VkResult on_vkFlushMappedMemoryRanges(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+ virtual VkResult on_vkInvalidateMappedMemoryRanges(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+ virtual void on_vkGetDeviceMemoryCommitment(
+ void* context,
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes);
+ virtual VkResult on_vkBindBufferMemory(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+ virtual VkResult on_vkBindImageMemory(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+ virtual void on_vkGetBufferMemoryRequirements(
+ void* context,
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements);
+ virtual void on_vkGetImageMemoryRequirements(
+ void* context,
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements);
+ virtual void on_vkGetImageSparseMemoryRequirements(
+ void* context,
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+ virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties);
+ virtual VkResult on_vkQueueBindSparse(
+ void* context,
+ VkResult input_result,
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence);
+ virtual VkResult on_vkCreateFence(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ virtual void on_vkDestroyFence(
+ void* context,
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkResetFences(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences);
+ virtual VkResult on_vkGetFenceStatus(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkFence fence);
+ virtual VkResult on_vkWaitForFences(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout);
+ virtual VkResult on_vkCreateSemaphore(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore);
+ virtual void on_vkDestroySemaphore(
+ void* context,
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateEvent(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent);
+ virtual void on_vkDestroyEvent(
+ void* context,
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetEventStatus(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkEvent event);
+ virtual VkResult on_vkSetEvent(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkEvent event);
+ virtual VkResult on_vkResetEvent(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkEvent event);
+ virtual VkResult on_vkCreateQueryPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool);
+ virtual void on_vkDestroyQueryPool(
+ void* context,
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetQueryPoolResults(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+ virtual VkResult on_vkCreateBuffer(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer);
+ virtual void on_vkDestroyBuffer(
+ void* context,
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateBufferView(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView);
+ virtual void on_vkDestroyBufferView(
+ void* context,
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateImage(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage);
+ virtual void on_vkDestroyImage(
+ void* context,
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkGetImageSubresourceLayout(
+ void* context,
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout);
+ virtual VkResult on_vkCreateImageView(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView);
+ virtual void on_vkDestroyImageView(
+ void* context,
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateShaderModule(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule);
+ virtual void on_vkDestroyShaderModule(
+ void* context,
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreatePipelineCache(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache);
+ virtual void on_vkDestroyPipelineCache(
+ void* context,
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetPipelineCacheData(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData);
+ virtual VkResult on_vkMergePipelineCaches(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches);
+ virtual VkResult on_vkCreateGraphicsPipelines(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+ virtual VkResult on_vkCreateComputePipelines(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+ virtual void on_vkDestroyPipeline(
+ void* context,
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreatePipelineLayout(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout);
+ virtual void on_vkDestroyPipelineLayout(
+ void* context,
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateSampler(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler);
+ virtual void on_vkDestroySampler(
+ void* context,
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateDescriptorSetLayout(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout);
+ virtual void on_vkDestroyDescriptorSetLayout(
+ void* context,
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateDescriptorPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool);
+ virtual void on_vkDestroyDescriptorPool(
+ void* context,
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkResetDescriptorPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags);
+ virtual VkResult on_vkAllocateDescriptorSets(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets);
+ virtual VkResult on_vkFreeDescriptorSets(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets);
+ virtual void on_vkUpdateDescriptorSets(
+ void* context,
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies);
+ virtual VkResult on_vkCreateFramebuffer(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer);
+ virtual void on_vkDestroyFramebuffer(
+ void* context,
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateRenderPass(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+ virtual void on_vkDestroyRenderPass(
+ void* context,
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkGetRenderAreaGranularity(
+ void* context,
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity);
+ virtual VkResult on_vkCreateCommandPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool);
+ virtual void on_vkDestroyCommandPool(
+ void* context,
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkResetCommandPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags);
+ virtual VkResult on_vkAllocateCommandBuffers(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers);
+ virtual void on_vkFreeCommandBuffers(
+ void* context,
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+ virtual VkResult on_vkBeginCommandBuffer(
+ void* context,
+ VkResult input_result,
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo);
+ virtual VkResult on_vkEndCommandBuffer(
+ void* context,
+ VkResult input_result,
+ VkCommandBuffer commandBuffer);
+ virtual VkResult on_vkResetCommandBuffer(
+ void* context,
+ VkResult input_result,
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags);
+ virtual void on_vkCmdBindPipeline(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline);
+ virtual void on_vkCmdSetViewport(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport* pViewports);
+ virtual void on_vkCmdSetScissor(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors);
+ virtual void on_vkCmdSetLineWidth(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ float lineWidth);
+ virtual void on_vkCmdSetDepthBias(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor);
+ virtual void on_vkCmdSetBlendConstants(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const float blendConstants);
+ virtual void on_vkCmdSetDepthBounds(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds);
+ virtual void on_vkCmdSetStencilCompareMask(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask);
+ virtual void on_vkCmdSetStencilWriteMask(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask);
+ virtual void on_vkCmdSetStencilReference(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference);
+ virtual void on_vkCmdBindDescriptorSets(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets);
+ virtual void on_vkCmdBindIndexBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType);
+ virtual void on_vkCmdBindVertexBuffers(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets);
+ virtual void on_vkCmdDraw(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance);
+ virtual void on_vkCmdDrawIndexed(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance);
+ virtual void on_vkCmdDrawIndirect(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+ virtual void on_vkCmdDrawIndexedIndirect(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+ virtual void on_vkCmdDispatch(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+ virtual void on_vkCmdDispatchIndirect(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset);
+ virtual void on_vkCmdCopyBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions);
+ virtual void on_vkCmdCopyImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions);
+ virtual void on_vkCmdBlitImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter);
+ virtual void on_vkCmdCopyBufferToImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+ virtual void on_vkCmdCopyImageToBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+ virtual void on_vkCmdUpdateBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData);
+ virtual void on_vkCmdFillBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data);
+ virtual void on_vkCmdClearColorImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+ virtual void on_vkCmdClearDepthStencilImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+ virtual void on_vkCmdClearAttachments(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects);
+ virtual void on_vkCmdResolveImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions);
+ virtual void on_vkCmdSetEvent(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+ virtual void on_vkCmdResetEvent(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+ virtual void on_vkCmdWaitEvents(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers);
+ virtual void on_vkCmdPipelineBarrier(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers);
+ virtual void on_vkCmdBeginQuery(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags);
+ virtual void on_vkCmdEndQuery(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query);
+ virtual void on_vkCmdResetQueryPool(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount);
+ virtual void on_vkCmdWriteTimestamp(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query);
+ virtual void on_vkCmdCopyQueryPoolResults(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+ virtual void on_vkCmdPushConstants(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues);
+ virtual void on_vkCmdBeginRenderPass(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents);
+ virtual void on_vkCmdNextSubpass(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents);
+ virtual void on_vkCmdEndRenderPass(
+ void* context,
+ VkCommandBuffer commandBuffer);
+ virtual void on_vkCmdExecuteCommands(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+#endif
+#ifdef VK_VERSION_1_1
+ virtual VkResult on_vkEnumerateInstanceVersion(
+ void* context,
+ VkResult input_result,
+ uint32_t* pApiVersion);
+ virtual VkResult on_vkBindBufferMemory2(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos);
+ virtual VkResult on_vkBindImageMemory2(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos);
+ virtual void on_vkGetDeviceGroupPeerMemoryFeatures(
+ void* context,
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+ virtual void on_vkCmdSetDeviceMask(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask);
+ virtual void on_vkCmdDispatchBase(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+ virtual VkResult on_vkEnumeratePhysicalDeviceGroups(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+ virtual void on_vkGetImageMemoryRequirements2(
+ void* context,
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ virtual void on_vkGetBufferMemoryRequirements2(
+ void* context,
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ virtual void on_vkGetImageSparseMemoryRequirements2(
+ void* context,
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+ virtual void on_vkGetPhysicalDeviceFeatures2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures);
+ virtual void on_vkGetPhysicalDeviceProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties);
+ virtual void on_vkGetPhysicalDeviceFormatProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties);
+ virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties2(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties);
+ virtual void on_vkGetPhysicalDeviceQueueFamilyProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties);
+ virtual void on_vkGetPhysicalDeviceMemoryProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+ virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties);
+ virtual void on_vkTrimCommandPool(
+ void* context,
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags);
+ virtual void on_vkGetDeviceQueue2(
+ void* context,
+ VkDevice device,
+ const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue);
+ virtual VkResult on_vkCreateSamplerYcbcrConversion(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion);
+ virtual void on_vkDestroySamplerYcbcrConversion(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateDescriptorUpdateTemplate(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+ virtual void on_vkDestroyDescriptorUpdateTemplate(
+ void* context,
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkUpdateDescriptorSetWithTemplate(
+ void* context,
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData);
+ virtual void on_vkGetPhysicalDeviceExternalBufferProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties);
+ virtual void on_vkGetPhysicalDeviceExternalFenceProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties);
+ virtual void on_vkGetPhysicalDeviceExternalSemaphoreProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+ virtual void on_vkGetDescriptorSetLayoutSupport(
+ void* context,
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_surface
+ virtual void on_vkDestroySurfaceKHR(
+ void* context,
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceSupportKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported);
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceFormatsKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats);
+ virtual VkResult on_vkGetPhysicalDeviceSurfacePresentModesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes);
+#endif
+#ifdef VK_KHR_swapchain
+ virtual VkResult on_vkCreateSwapchainKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain);
+ virtual void on_vkDestroySwapchainKHR(
+ void* context,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetSwapchainImagesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages);
+ virtual VkResult on_vkAcquireNextImageKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex);
+ virtual VkResult on_vkQueuePresentKHR(
+ void* context,
+ VkResult input_result,
+ VkQueue queue,
+ const VkPresentInfoKHR* pPresentInfo);
+ virtual VkResult on_vkGetDeviceGroupPresentCapabilitiesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
+ virtual VkResult on_vkGetDeviceGroupSurfacePresentModesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHR* pModes);
+ virtual VkResult on_vkGetPhysicalDevicePresentRectanglesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects);
+ virtual VkResult on_vkAcquireNextImage2KHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex);
+#endif
+#ifdef VK_KHR_display
+ virtual VkResult on_vkGetPhysicalDeviceDisplayPropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties);
+ virtual VkResult on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties);
+ virtual VkResult on_vkGetDisplayPlaneSupportedDisplaysKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays);
+ virtual VkResult on_vkGetDisplayModePropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties);
+ virtual VkResult on_vkCreateDisplayModeKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode);
+ virtual VkResult on_vkGetDisplayPlaneCapabilitiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+ virtual VkResult on_vkCreateDisplayPlaneSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_display_swapchain
+ virtual VkResult on_vkCreateSharedSwapchainsKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains);
+#endif
+#ifdef VK_KHR_xlib_surface
+ virtual VkResult on_vkCreateXlibSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID);
+#endif
+#ifdef VK_KHR_xcb_surface
+ virtual VkResult on_vkCreateXcbSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id);
+#endif
+#ifdef VK_KHR_wayland_surface
+ virtual VkResult on_vkCreateWaylandSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ wl_display* display);
+#endif
+#ifdef VK_KHR_mir_surface
+ virtual VkResult on_vkCreateMirSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceMirPresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection);
+#endif
+#ifdef VK_KHR_android_surface
+ virtual VkResult on_vkCreateAndroidSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_win32_surface
+ virtual VkResult on_vkCreateWin32SurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex);
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+ virtual void on_vkGetPhysicalDeviceFeatures2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures);
+ virtual void on_vkGetPhysicalDeviceProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties);
+ virtual void on_vkGetPhysicalDeviceFormatProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties);
+ virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties);
+ virtual void on_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties);
+ virtual void on_vkGetPhysicalDeviceMemoryProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+ virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties);
+#endif
+#ifdef VK_KHR_device_group
+ virtual void on_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+ void* context,
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+ virtual void on_vkCmdSetDeviceMaskKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask);
+ virtual void on_vkCmdDispatchBaseKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+ virtual void on_vkTrimCommandPoolKHR(
+ void* context,
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags);
+#endif
+#ifdef VK_KHR_device_group_creation
+ virtual VkResult on_vkEnumeratePhysicalDeviceGroupsKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+ virtual void on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties);
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+ virtual VkResult on_vkGetMemoryWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+ virtual VkResult on_vkGetMemoryWin32HandlePropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+#endif
+#ifdef VK_KHR_external_memory_fd
+ virtual VkResult on_vkGetMemoryFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+ virtual VkResult on_vkGetMemoryFdPropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+ virtual void on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+ virtual VkResult on_vkImportSemaphoreWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+ virtual VkResult on_vkGetSemaphoreWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+ virtual VkResult on_vkImportSemaphoreFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+ virtual VkResult on_vkGetSemaphoreFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+#endif
+#ifdef VK_KHR_push_descriptor
+ virtual void on_vkCmdPushDescriptorSetKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites);
+ virtual void on_vkCmdPushDescriptorSetWithTemplateKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData);
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+ virtual VkResult on_vkCreateDescriptorUpdateTemplateKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+ virtual void on_vkDestroyDescriptorUpdateTemplateKHR(
+ void* context,
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkUpdateDescriptorSetWithTemplateKHR(
+ void* context,
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData);
+#endif
+#ifdef VK_KHR_create_renderpass2
+ virtual VkResult on_vkCreateRenderPass2KHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkRenderPassCreateInfo2KHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+ virtual void on_vkCmdBeginRenderPass2KHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
+ virtual void on_vkCmdNextSubpass2KHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo);
+ virtual void on_vkCmdEndRenderPass2KHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo);
+#endif
+#ifdef VK_KHR_shared_presentable_image
+ virtual VkResult on_vkGetSwapchainStatusKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain);
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+ virtual void on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties);
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+ virtual VkResult on_vkImportFenceWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+ virtual VkResult on_vkGetFenceWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_fence_fd
+ virtual VkResult on_vkImportFenceFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+ virtual VkResult on_vkGetFenceFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceFormats2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats);
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+ virtual VkResult on_vkGetPhysicalDeviceDisplayProperties2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties);
+ virtual VkResult on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties);
+ virtual VkResult on_vkGetDisplayModeProperties2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties);
+ virtual VkResult on_vkGetDisplayPlaneCapabilities2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities);
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+ virtual void on_vkGetImageMemoryRequirements2KHR(
+ void* context,
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ virtual void on_vkGetBufferMemoryRequirements2KHR(
+ void* context,
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ virtual void on_vkGetImageSparseMemoryRequirements2KHR(
+ void* context,
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+ virtual VkResult on_vkCreateSamplerYcbcrConversionKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion);
+ virtual void on_vkDestroySamplerYcbcrConversionKHR(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
+#endif
+#ifdef VK_KHR_bind_memory2
+ virtual VkResult on_vkBindBufferMemory2KHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos);
+ virtual VkResult on_vkBindImageMemory2KHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos);
+#endif
+#ifdef VK_KHR_maintenance3
+ virtual void on_vkGetDescriptorSetLayoutSupportKHR(
+ void* context,
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_draw_indirect_count
+ virtual void on_vkCmdDrawIndirectCountKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+ virtual void on_vkCmdDrawIndexedIndirectCountKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+ virtual VkResult on_vkGetSwapchainGrallocUsageANDROID(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage);
+ virtual VkResult on_vkAcquireImageANDROID(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkImage image,
+ int nativeFenceFd,
+ VkSemaphore semaphore,
+ VkFence fence);
+ virtual VkResult on_vkQueueSignalReleaseImageANDROID(
+ void* context,
+ VkResult input_result,
+ VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image,
+ int* pNativeFenceFd);
+#endif
+#ifdef VK_EXT_debug_report
+ virtual VkResult on_vkCreateDebugReportCallbackEXT(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback);
+ virtual void on_vkDestroyDebugReportCallbackEXT(
+ void* context,
+ VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkDebugReportMessageEXT(
+ void* context,
+ VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char* pLayerPrefix,
+ const char* pMessage);
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+ virtual VkResult on_vkDebugMarkerSetObjectTagEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+ virtual VkResult on_vkDebugMarkerSetObjectNameEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+ virtual void on_vkCmdDebugMarkerBeginEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+ virtual void on_vkCmdDebugMarkerEndEXT(
+ void* context,
+ VkCommandBuffer commandBuffer);
+ virtual void on_vkCmdDebugMarkerInsertEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+ virtual void on_vkCmdDrawIndirectCountAMD(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+ virtual void on_vkCmdDrawIndexedIndirectCountAMD(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+ virtual VkResult on_vkGetShaderInfoAMD(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType,
+ size_t* pInfoSize,
+ void* pInfo);
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+ virtual VkResult on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+ virtual VkResult on_vkGetMemoryWin32HandleNV(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+ virtual VkResult on_vkCreateViSurfaceNN(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+ virtual void on_vkCmdBeginConditionalRenderingEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+ virtual void on_vkCmdEndConditionalRenderingEXT(
+ void* context,
+ VkCommandBuffer commandBuffer);
+#endif
+#ifdef VK_NVX_device_generated_commands
+ virtual void on_vkCmdProcessCommandsNVX(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
+ virtual void on_vkCmdReserveSpaceForCommandsNVX(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
+ virtual VkResult on_vkCreateIndirectCommandsLayoutNVX(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
+ virtual void on_vkDestroyIndirectCommandsLayoutNVX(
+ void* context,
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateObjectTableNVX(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable);
+ virtual void on_vkDestroyObjectTableNVX(
+ void* context,
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkRegisterObjectsNVX(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices);
+ virtual VkResult on_vkUnregisterObjectsNVX(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices);
+ virtual void on_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits);
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+ virtual void on_vkCmdSetViewportWScalingNV(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings);
+#endif
+#ifdef VK_EXT_direct_mode_display
+ virtual VkResult on_vkReleaseDisplayEXT(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display);
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+ virtual VkResult on_vkAcquireXlibDisplayEXT(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display);
+ virtual VkResult on_vkGetRandROutputDisplayEXT(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay);
+#endif
+#ifdef VK_EXT_display_surface_counter
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+#endif
+#ifdef VK_EXT_display_control
+ virtual VkResult on_vkDisplayPowerControlEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+ virtual VkResult on_vkRegisterDeviceEventEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ virtual VkResult on_vkRegisterDisplayEventEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ virtual VkResult on_vkGetSwapchainCounterEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue);
+#endif
+#ifdef VK_GOOGLE_display_timing
+ virtual VkResult on_vkGetRefreshCycleDurationGOOGLE(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+ virtual VkResult on_vkGetPastPresentationTimingGOOGLE(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings);
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+ virtual void on_vkCmdSetDiscardRectangleEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles);
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+ virtual void on_vkSetHdrMetadataEXT(
+ void* context,
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata);
+#endif
+#ifdef VK_MVK_ios_surface
+ virtual VkResult on_vkCreateIOSSurfaceMVK(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_MVK_macos_surface
+ virtual VkResult on_vkCreateMacOSSurfaceMVK(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+ virtual VkResult on_vkSetDebugUtilsObjectNameEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+ virtual VkResult on_vkSetDebugUtilsObjectTagEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+ virtual void on_vkQueueBeginDebugUtilsLabelEXT(
+ void* context,
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ virtual void on_vkQueueEndDebugUtilsLabelEXT(
+ void* context,
+ VkQueue queue);
+ virtual void on_vkQueueInsertDebugUtilsLabelEXT(
+ void* context,
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ virtual void on_vkCmdBeginDebugUtilsLabelEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ virtual void on_vkCmdEndDebugUtilsLabelEXT(
+ void* context,
+ VkCommandBuffer commandBuffer);
+ virtual void on_vkCmdInsertDebugUtilsLabelEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ virtual VkResult on_vkCreateDebugUtilsMessengerEXT(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger);
+ virtual void on_vkDestroyDebugUtilsMessengerEXT(
+ void* context,
+ VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkSubmitDebugUtilsMessageEXT(
+ void* context,
+ VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+ virtual VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+ virtual VkResult on_vkGetMemoryAndroidHardwareBufferANDROID(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer);
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+ virtual void on_vkCmdSetSampleLocationsEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
+ virtual void on_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties);
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+ virtual VkResult on_vkCreateValidationCacheEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache);
+ virtual void on_vkDestroyValidationCacheEXT(
+ void* context,
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkMergeValidationCachesEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches);
+ virtual VkResult on_vkGetValidationCacheDataEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize,
+ void* pData);
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+ virtual VkResult on_vkGetMemoryHostPointerPropertiesEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+#endif
+#ifdef VK_AMD_buffer_marker
+ virtual void on_vkCmdWriteBufferMarkerAMD(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ uint32_t marker);
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+ virtual void on_vkCmdSetCheckpointNV(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const void* pCheckpointMarker);
+ virtual void on_vkGetQueueCheckpointDataNV(
+ void* context,
+ VkQueue queue,
+ uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData);
+#endif
+
+};
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VulkanHandleMapping.cpp b/system/vulkan_enc/VulkanHandleMapping.cpp
new file mode 100644
index 0000000..649244f
--- /dev/null
+++ b/system/vulkan_enc/VulkanHandleMapping.cpp
@@ -0,0 +1,33 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <vulkan/vulkan.h>
+
+#include "VulkanHandleMapping.h"
+
+namespace goldfish_vk {
+
+#define DEFAULT_HANDLE_MAP_DEFINE(type) \
+void DefaultHandleMapping::mapHandles_##type(type*, size_t) { return; } \
+void DefaultHandleMapping::mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) { \
+ for (size_t i = 0; i < count; ++i) { handle_u64s[i] = (uint64_t)(uintptr_t)handles[i]; } \
+} \
+void DefaultHandleMapping::mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) { \
+ for (size_t i = 0; i < count; ++i) { handles[i] = (type)(uintptr_t)handle_u64s[i]; } \
+} \
+
+GOLDFISH_VK_LIST_HANDLE_TYPES(DEFAULT_HANDLE_MAP_DEFINE)
+
+} // namespace goldfish_vk
+
diff --git a/system/vulkan_enc/VulkanHandleMapping.h b/system/vulkan_enc/VulkanHandleMapping.h
new file mode 100644
index 0000000..5c03d7f
--- /dev/null
+++ b/system/vulkan_enc/VulkanHandleMapping.h
@@ -0,0 +1,48 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#include "VulkanHandles.h"
+
+namespace goldfish_vk {
+
+class VulkanHandleMapping {
+public:
+ VulkanHandleMapping() = default;
+ virtual ~VulkanHandleMapping() { }
+
+#define DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD(type) \
+ virtual void mapHandles_##type(type* handles, size_t count = 1) = 0; \
+ virtual void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count = 1) = 0; \
+ virtual void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count = 1) = 0; \
+
+ GOLDFISH_VK_LIST_HANDLE_TYPES(DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD)
+};
+
+class DefaultHandleMapping : public VulkanHandleMapping {
+public:
+ virtual ~DefaultHandleMapping() { }
+
+#define DECLARE_HANDLE_MAP_OVERRIDE(type) \
+ void mapHandles_##type(type* handles, size_t count) override; \
+ void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) override; \
+ void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) override; \
+
+ GOLDFISH_VK_LIST_HANDLE_TYPES(DECLARE_HANDLE_MAP_OVERRIDE)
+};
+
+} // namespace goldfish_vk
\ No newline at end of file
diff --git a/system/vulkan_enc/VulkanHandles.h b/system/vulkan_enc/VulkanHandles.h
new file mode 100644
index 0000000..af130eb
--- /dev/null
+++ b/system/vulkan_enc/VulkanHandles.h
@@ -0,0 +1,71 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#define GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
+ f(VkInstance) \
+ f(VkPhysicalDevice) \
+ f(VkQueue) \
+ f(VkCommandBuffer) \
+
+#define GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
+ f(VkDevice) \
+ GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
+
+#define GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+ f(VkBuffer) \
+ f(VkBufferView) \
+ f(VkImage) \
+ f(VkImageView) \
+ f(VkShaderModule) \
+ f(VkDescriptorPool) \
+ f(VkDescriptorSetLayout) \
+ f(VkDescriptorSet) \
+ f(VkSampler) \
+ f(VkPipeline) \
+ f(VkPipelineCache) \
+ f(VkPipelineLayout) \
+ f(VkRenderPass) \
+ f(VkFramebuffer) \
+ f(VkCommandPool) \
+ f(VkFence) \
+ f(VkSemaphore) \
+ f(VkEvent) \
+ f(VkQueryPool) \
+ f(VkSamplerYcbcrConversion) \
+ f(VkDescriptorUpdateTemplate) \
+ f(VkSurfaceKHR) \
+ f(VkSwapchainKHR) \
+ f(VkDisplayKHR) \
+ f(VkDisplayModeKHR) \
+ f(VkObjectTableNVX) \
+ f(VkIndirectCommandsLayoutNVX) \
+ f(VkValidationCacheEXT) \
+ f(VkDebugReportCallbackEXT) \
+ f(VkDebugUtilsMessengerEXT) \
+
+#define GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+ f(VkDeviceMemory) \
+ GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+
+#define GOLDFISH_VK_LIST_HANDLE_TYPES(f) \
+ GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
+ GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f)
+
+#define GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(f) \
+ GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
+ GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
diff --git a/system/vulkan_enc/VulkanStream.cpp b/system/vulkan_enc/VulkanStream.cpp
new file mode 100644
index 0000000..f862bf7
--- /dev/null
+++ b/system/vulkan_enc/VulkanStream.cpp
@@ -0,0 +1,200 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "VulkanStream.h"
+
+#include "IOStream.h"
+
+#include "android/base/Pool.h"
+
+#include <vector>
+
+#include <cutils/log.h>
+#include <inttypes.h>
+
+namespace goldfish_vk {
+
+class VulkanStream::Impl : public android::base::Stream {
+public:
+ Impl(IOStream* stream) : mStream(stream) { unsetHandleMapping(); }
+
+ ~Impl() { }
+
+ bool valid() { return true; }
+
+ void alloc(void **ptrAddr, size_t bytes) {
+ if (!bytes) {
+ *ptrAddr = nullptr;
+ return;
+ }
+
+ *ptrAddr = mPool.alloc(bytes);
+ }
+
+ ssize_t write(const void *buffer, size_t size) override {
+ return bufferedWrite(buffer, size);
+ }
+
+ ssize_t read(void *buffer, size_t size) override {
+ commitWrite();
+ if (!mStream->readFully(buffer, size)) {
+ ALOGE("FATAL: Could not read back %zu bytes", size);
+ abort();
+ }
+ return size;
+ }
+
+ void clearPool() {
+ mPool.freeAll();
+ }
+
+ void setHandleMapping(VulkanHandleMapping* mapping) {
+ mCurrentHandleMapping = mapping;
+ }
+
+ void unsetHandleMapping() {
+ mCurrentHandleMapping = &mDefaultHandleMapping;
+ }
+
+ VulkanHandleMapping* handleMapping() const {
+ return mCurrentHandleMapping;
+ }
+
+private:
+ size_t oustandingWriteBuffer() const {
+ return mWritePos;
+ }
+
+ size_t remainingWriteBufferSize() const {
+ return mWriteBuffer.size() - mWritePos;
+ }
+
+ void commitWrite() {
+ if (!valid()) {
+ ALOGE("FATAL: Tried to commit write to vulkan pipe with invalid pipe!");
+ abort();
+ }
+
+ int written =
+ mStream->writeFully(mWriteBuffer.data(), mWritePos);
+
+ if (written) {
+ ALOGE("FATAL: Did not write exactly %zu bytes!",
+ mWritePos);
+ abort();
+ }
+ mWritePos = 0;
+ }
+
+ ssize_t bufferedWrite(const void *buffer, size_t size) {
+ if (size > remainingWriteBufferSize()) {
+ mWriteBuffer.resize((mWritePos + size) << 1);
+ }
+ memcpy(mWriteBuffer.data() + mWritePos, buffer, size);
+ mWritePos += size;
+ return size;
+ }
+
+ android::base::Pool mPool { 8, 4096, 64 };
+
+ size_t mWritePos = 0;
+ std::vector<uint8_t> mWriteBuffer;
+ IOStream* mStream = nullptr;
+ DefaultHandleMapping mDefaultHandleMapping;
+ VulkanHandleMapping* mCurrentHandleMapping;
+};
+
+VulkanStream::VulkanStream(IOStream *stream) :
+ mImpl(new VulkanStream::Impl(stream)) { }
+
+VulkanStream::~VulkanStream() = default;
+
+bool VulkanStream::valid() {
+ return mImpl->valid();
+}
+
+void VulkanStream::alloc(void** ptrAddr, size_t bytes) {
+ mImpl->alloc(ptrAddr, bytes);
+}
+
+void VulkanStream::loadStringInPlace(char** forOutput) {
+ size_t len = getBe32();
+
+ alloc((void**)forOutput, len + 1);
+
+ memset(*forOutput, 0x0, len + 1);
+
+ if (len > 0) read(*forOutput, len);
+}
+
+void VulkanStream::loadStringArrayInPlace(char*** forOutput) {
+ size_t count = getBe32();
+
+ if (!count) {
+ *forOutput = nullptr;
+ return;
+ }
+
+ alloc((void**)forOutput, count * sizeof(char*));
+
+ char **stringsForOutput = *forOutput;
+
+ for (size_t i = 0; i < count; i++) {
+ loadStringInPlace(stringsForOutput + i);
+ }
+}
+
+
+ssize_t VulkanStream::read(void *buffer, size_t size) {
+ return mImpl->read(buffer, size);
+}
+
+ssize_t VulkanStream::write(const void *buffer, size_t size) {
+ return mImpl->write(buffer, size);
+}
+
+void VulkanStream::clearPool() {
+ mImpl->clearPool();
+}
+
+void VulkanStream::setHandleMapping(VulkanHandleMapping* mapping) {
+ mImpl->setHandleMapping(mapping);
+}
+
+void VulkanStream::unsetHandleMapping() {
+ mImpl->unsetHandleMapping();
+}
+
+VulkanHandleMapping* VulkanStream::handleMapping() const {
+ return mImpl->handleMapping();
+}
+
+VulkanCountingStream::VulkanCountingStream() : VulkanStream(nullptr) { }
+VulkanCountingStream::~VulkanCountingStream() = default;
+
+ssize_t VulkanCountingStream::read(void*, size_t size) {
+ m_read += size;
+ return size;
+}
+
+ssize_t VulkanCountingStream::write(const void*, size_t size) {
+ m_written += size;
+ return size;
+}
+
+void VulkanCountingStream::rewind() {
+ m_written = 0;
+ m_read = 0;
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VulkanStream.h b/system/vulkan_enc/VulkanStream.h
new file mode 100644
index 0000000..b763f32
--- /dev/null
+++ b/system/vulkan_enc/VulkanStream.h
@@ -0,0 +1,75 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include "android/base/files/Stream.h"
+#include "android/base/files/StreamSerializing.h"
+
+#include "VulkanHandleMapping.h"
+
+#include <memory>
+
+class IOStream;
+
+namespace goldfish_vk {
+
+class VulkanStream : public android::base::Stream {
+public:
+ VulkanStream(IOStream* stream);
+ ~VulkanStream();
+
+ // Returns whether the connection is valid.
+ bool valid();
+
+ // General allocation function
+ void alloc(void** ptrAddr, size_t bytes);
+
+ // Utility functions to load strings or
+ // string arrays in place with allocation.
+ void loadStringInPlace(char** forOutput);
+ void loadStringArrayInPlace(char*** forOutput);
+
+ ssize_t read(void *buffer, size_t size) override;
+ ssize_t write(const void *buffer, size_t size) override;
+
+ // Frees everything that got alloc'ed.
+ void clearPool();
+
+ void setHandleMapping(VulkanHandleMapping* mapping);
+ void unsetHandleMapping();
+ VulkanHandleMapping* handleMapping() const;
+
+private:
+ class Impl;
+ std::unique_ptr<Impl> mImpl;
+};
+
+class VulkanCountingStream : public VulkanStream {
+public:
+ VulkanCountingStream();
+ ~VulkanCountingStream();
+
+ ssize_t read(void *buffer, size_t size) override;
+ ssize_t write(const void *buffer, size_t size) override;
+
+ size_t bytesWritten() const { return m_written; }
+ size_t bytesRead() const { return m_read; }
+
+ void rewind();
+private:
+ size_t m_written = 0;
+ size_t m_read = 0;
+};
+
+} // namespace goldfish_vk
\ No newline at end of file
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
new file mode 100644
index 0000000..c481e3c
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -0,0 +1,7000 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_deepcopy_guest
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "goldfish_vk_deepcopy_guest.h"
+
+
+#include "goldfish_vk_extension_structs_guest.h"
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+void deepcopy_extension_struct(
+ Pool* pool,
+ const void* structExtension,
+ void* structExtension_out);
+
+#ifdef VK_VERSION_1_0
+void deepcopy_VkApplicationInfo(
+ Pool* pool,
+ const VkApplicationInfo* from,
+ VkApplicationInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pApplicationName = nullptr;
+ if (from->pApplicationName)
+ {
+ to->pApplicationName = pool->strDup(from->pApplicationName);
+ }
+ to->pEngineName = nullptr;
+ if (from->pEngineName)
+ {
+ to->pEngineName = pool->strDup(from->pEngineName);
+ }
+}
+
+void deepcopy_VkInstanceCreateInfo(
+ Pool* pool,
+ const VkInstanceCreateInfo* from,
+ VkInstanceCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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->ppEnabledLayerNames = nullptr;
+ if (from->ppEnabledLayerNames && from->enabledLayerCount)
+ {
+ to->ppEnabledLayerNames = pool->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
+ }
+ to->ppEnabledExtensionNames = nullptr;
+ if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
+ {
+ to->ppEnabledExtensionNames = pool->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
+ }
+}
+
+void deepcopy_VkAllocationCallbacks(
+ Pool* pool,
+ const VkAllocationCallbacks* from,
+ VkAllocationCallbacks* to)
+{
+ (void)pool;
+ *to = *from;
+ to->pUserData = nullptr;
+ if (from->pUserData)
+ {
+ to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceFeatures* from,
+ VkPhysicalDeviceFeatures* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkFormatProperties(
+ Pool* pool,
+ const VkFormatProperties* from,
+ VkFormatProperties* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkExtent3D(
+ Pool* pool,
+ const VkExtent3D* from,
+ VkExtent3D* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkImageFormatProperties(
+ Pool* pool,
+ const VkImageFormatProperties* from,
+ VkImageFormatProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkExtent3D(pool, &from->maxExtent, (VkExtent3D*)(&to->maxExtent));
+}
+
+void deepcopy_VkPhysicalDeviceLimits(
+ Pool* pool,
+ const VkPhysicalDeviceLimits* from,
+ VkPhysicalDeviceLimits* to)
+{
+ (void)pool;
+ *to = *from;
+ memcpy(to->maxComputeWorkGroupCount, from->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
+ memcpy(to->maxComputeWorkGroupSize, from->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
+ memcpy(to->maxViewportDimensions, from->maxViewportDimensions, 2 * sizeof(uint32_t));
+ memcpy(to->viewportBoundsRange, from->viewportBoundsRange, 2 * sizeof(float));
+ memcpy(to->pointSizeRange, from->pointSizeRange, 2 * sizeof(float));
+ memcpy(to->lineWidthRange, from->lineWidthRange, 2 * sizeof(float));
+}
+
+void deepcopy_VkPhysicalDeviceSparseProperties(
+ Pool* pool,
+ const VkPhysicalDeviceSparseProperties* from,
+ VkPhysicalDeviceSparseProperties* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPhysicalDeviceProperties(
+ Pool* pool,
+ const VkPhysicalDeviceProperties* from,
+ VkPhysicalDeviceProperties* to)
+{
+ (void)pool;
+ *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));
+}
+
+void deepcopy_VkQueueFamilyProperties(
+ Pool* pool,
+ const VkQueueFamilyProperties* from,
+ VkQueueFamilyProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkExtent3D(pool, &from->minImageTransferGranularity, (VkExtent3D*)(&to->minImageTransferGranularity));
+}
+
+void deepcopy_VkMemoryType(
+ Pool* pool,
+ const VkMemoryType* from,
+ VkMemoryType* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkMemoryHeap(
+ Pool* pool,
+ const VkMemoryHeap* from,
+ VkMemoryHeap* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPhysicalDeviceMemoryProperties(
+ Pool* pool,
+ const VkPhysicalDeviceMemoryProperties* from,
+ VkPhysicalDeviceMemoryProperties* to)
+{
+ (void)pool;
+ *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));
+ }
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
+ {
+ deepcopy_VkMemoryHeap(pool, from->memoryHeaps + i, (VkMemoryHeap*)(to->memoryHeaps + i));
+ }
+}
+
+void deepcopy_VkDeviceQueueCreateInfo(
+ Pool* pool,
+ const VkDeviceQueueCreateInfo* from,
+ VkDeviceQueueCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pQueuePriorities = nullptr;
+ if (from->pQueuePriorities)
+ {
+ to->pQueuePriorities = (float*)pool->dupArray(from->pQueuePriorities, from->queueCount * sizeof(const float));
+ }
+}
+
+void deepcopy_VkDeviceCreateInfo(
+ Pool* pool,
+ const VkDeviceCreateInfo* from,
+ VkDeviceCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pQueueCreateInfos = nullptr;
+ if (from->pQueueCreateInfos)
+ {
+ to->pQueueCreateInfos = (VkDeviceQueueCreateInfo*)pool->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));
+ }
+ }
+ to->ppEnabledLayerNames = nullptr;
+ if (from->ppEnabledLayerNames && from->enabledLayerCount)
+ {
+ to->ppEnabledLayerNames = pool->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
+ }
+ to->ppEnabledExtensionNames = nullptr;
+ if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
+ {
+ to->ppEnabledExtensionNames = pool->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));
+ }
+}
+
+void deepcopy_VkExtensionProperties(
+ Pool* pool,
+ const VkExtensionProperties* from,
+ VkExtensionProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ memcpy(to->extensionName, from->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+}
+
+void deepcopy_VkLayerProperties(
+ Pool* pool,
+ const VkLayerProperties* from,
+ VkLayerProperties* to)
+{
+ (void)pool;
+ *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(
+ Pool* pool,
+ const VkSubmitInfo* from,
+ VkSubmitInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pWaitSemaphores = nullptr;
+ if (from->pWaitSemaphores)
+ {
+ to->pWaitSemaphores = (VkSemaphore*)pool->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->pCommandBuffers = nullptr;
+ if (from->pCommandBuffers)
+ {
+ to->pCommandBuffers = (VkCommandBuffer*)pool->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));
+ }
+}
+
+void deepcopy_VkMemoryAllocateInfo(
+ Pool* pool,
+ const VkMemoryAllocateInfo* from,
+ VkMemoryAllocateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMappedMemoryRange(
+ Pool* pool,
+ const VkMappedMemoryRange* from,
+ VkMappedMemoryRange* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryRequirements(
+ Pool* pool,
+ const VkMemoryRequirements* from,
+ VkMemoryRequirements* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkSparseImageFormatProperties(
+ Pool* pool,
+ const VkSparseImageFormatProperties* from,
+ VkSparseImageFormatProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkExtent3D(pool, &from->imageGranularity, (VkExtent3D*)(&to->imageGranularity));
+}
+
+void deepcopy_VkSparseImageMemoryRequirements(
+ Pool* pool,
+ const VkSparseImageMemoryRequirements* from,
+ VkSparseImageMemoryRequirements* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkSparseImageFormatProperties(pool, &from->formatProperties, (VkSparseImageFormatProperties*)(&to->formatProperties));
+}
+
+void deepcopy_VkSparseMemoryBind(
+ Pool* pool,
+ const VkSparseMemoryBind* from,
+ VkSparseMemoryBind* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkSparseBufferMemoryBindInfo(
+ Pool* pool,
+ const VkSparseBufferMemoryBindInfo* from,
+ VkSparseBufferMemoryBindInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ to->pBinds = nullptr;
+ if (from->pBinds)
+ {
+ to->pBinds = (VkSparseMemoryBind*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
+ Pool* pool,
+ const VkSparseImageOpaqueMemoryBindInfo* from,
+ VkSparseImageOpaqueMemoryBindInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ to->pBinds = nullptr;
+ if (from->pBinds)
+ {
+ to->pBinds = (VkSparseMemoryBind*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkImageSubresource(
+ Pool* pool,
+ const VkImageSubresource* from,
+ VkImageSubresource* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkOffset3D(
+ Pool* pool,
+ const VkOffset3D* from,
+ VkOffset3D* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkSparseImageMemoryBind(
+ Pool* pool,
+ const VkSparseImageMemoryBind* from,
+ VkSparseImageMemoryBind* to)
+{
+ (void)pool;
+ *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));
+}
+
+void deepcopy_VkSparseImageMemoryBindInfo(
+ Pool* pool,
+ const VkSparseImageMemoryBindInfo* from,
+ VkSparseImageMemoryBindInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ to->pBinds = nullptr;
+ if (from->pBinds)
+ {
+ to->pBinds = (VkSparseImageMemoryBind*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkBindSparseInfo(
+ Pool* pool,
+ const VkBindSparseInfo* from,
+ VkBindSparseInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pWaitSemaphores = nullptr;
+ if (from->pWaitSemaphores)
+ {
+ to->pWaitSemaphores = (VkSemaphore*)pool->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+ }
+ to->pBufferBinds = nullptr;
+ if (from->pBufferBinds)
+ {
+ to->pBufferBinds = (VkSparseBufferMemoryBindInfo*)pool->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));
+ }
+ }
+ to->pImageOpaqueBinds = nullptr;
+ if (from->pImageOpaqueBinds)
+ {
+ to->pImageOpaqueBinds = (VkSparseImageOpaqueMemoryBindInfo*)pool->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));
+ }
+ }
+ to->pImageBinds = nullptr;
+ if (from->pImageBinds)
+ {
+ to->pImageBinds = (VkSparseImageMemoryBindInfo*)pool->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));
+ }
+ }
+ to->pSignalSemaphores = nullptr;
+ if (from->pSignalSemaphores)
+ {
+ to->pSignalSemaphores = (VkSemaphore*)pool->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
+ }
+}
+
+void deepcopy_VkFenceCreateInfo(
+ Pool* pool,
+ const VkFenceCreateInfo* from,
+ VkFenceCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkSemaphoreCreateInfo(
+ Pool* pool,
+ const VkSemaphoreCreateInfo* from,
+ VkSemaphoreCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkEventCreateInfo(
+ Pool* pool,
+ const VkEventCreateInfo* from,
+ VkEventCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkQueryPoolCreateInfo(
+ Pool* pool,
+ const VkQueryPoolCreateInfo* from,
+ VkQueryPoolCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBufferCreateInfo(
+ Pool* pool,
+ const VkBufferCreateInfo* from,
+ VkBufferCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+ }
+}
+
+void deepcopy_VkBufferViewCreateInfo(
+ Pool* pool,
+ const VkBufferViewCreateInfo* from,
+ VkBufferViewCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkImageCreateInfo(
+ Pool* pool,
+ const VkImageCreateInfo* from,
+ VkImageCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkExtent3D(pool, &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));
+ }
+}
+
+void deepcopy_VkSubresourceLayout(
+ Pool* pool,
+ const VkSubresourceLayout* from,
+ VkSubresourceLayout* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkComponentMapping(
+ Pool* pool,
+ const VkComponentMapping* from,
+ VkComponentMapping* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkImageSubresourceRange(
+ Pool* pool,
+ const VkImageSubresourceRange* from,
+ VkImageSubresourceRange* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkImageViewCreateInfo(
+ Pool* pool,
+ const VkImageViewCreateInfo* from,
+ VkImageViewCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkComponentMapping(pool, &from->components, (VkComponentMapping*)(&to->components));
+ deepcopy_VkImageSubresourceRange(pool, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
+}
+
+void deepcopy_VkShaderModuleCreateInfo(
+ Pool* pool,
+ const VkShaderModuleCreateInfo* from,
+ VkShaderModuleCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+ }
+}
+
+void deepcopy_VkPipelineCacheCreateInfo(
+ Pool* pool,
+ const VkPipelineCacheCreateInfo* from,
+ VkPipelineCacheCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pInitialData = nullptr;
+ if (from->pInitialData)
+ {
+ to->pInitialData = (void*)pool->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
+ }
+}
+
+void deepcopy_VkSpecializationMapEntry(
+ Pool* pool,
+ const VkSpecializationMapEntry* from,
+ VkSpecializationMapEntry* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkSpecializationInfo(
+ Pool* pool,
+ const VkSpecializationInfo* from,
+ VkSpecializationInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ to->pMapEntries = nullptr;
+ if (from->pMapEntries)
+ {
+ to->pMapEntries = (VkSpecializationMapEntry*)pool->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));
+ }
+ }
+ to->pData = nullptr;
+ if (from->pData)
+ {
+ to->pData = (void*)pool->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
+ }
+}
+
+void deepcopy_VkPipelineShaderStageCreateInfo(
+ Pool* pool,
+ const VkPipelineShaderStageCreateInfo* from,
+ VkPipelineShaderStageCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pName = nullptr;
+ if (from->pName)
+ {
+ to->pName = pool->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));
+ }
+}
+
+void deepcopy_VkVertexInputBindingDescription(
+ Pool* pool,
+ const VkVertexInputBindingDescription* from,
+ VkVertexInputBindingDescription* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkVertexInputAttributeDescription(
+ Pool* pool,
+ const VkVertexInputAttributeDescription* from,
+ VkVertexInputAttributeDescription* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPipelineVertexInputStateCreateInfo(
+ Pool* pool,
+ const VkPipelineVertexInputStateCreateInfo* from,
+ VkPipelineVertexInputStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pVertexBindingDescriptions = nullptr;
+ if (from->pVertexBindingDescriptions)
+ {
+ to->pVertexBindingDescriptions = (VkVertexInputBindingDescription*)pool->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));
+ }
+ }
+ to->pVertexAttributeDescriptions = nullptr;
+ if (from->pVertexAttributeDescriptions)
+ {
+ to->pVertexAttributeDescriptions = (VkVertexInputAttributeDescription*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
+ Pool* pool,
+ const VkPipelineInputAssemblyStateCreateInfo* from,
+ VkPipelineInputAssemblyStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineTessellationStateCreateInfo(
+ Pool* pool,
+ const VkPipelineTessellationStateCreateInfo* from,
+ VkPipelineTessellationStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkViewport(
+ Pool* pool,
+ const VkViewport* from,
+ VkViewport* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkOffset2D(
+ Pool* pool,
+ const VkOffset2D* from,
+ VkOffset2D* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkExtent2D(
+ Pool* pool,
+ const VkExtent2D* from,
+ VkExtent2D* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkRect2D(
+ Pool* pool,
+ const VkRect2D* from,
+ VkRect2D* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkOffset2D(pool, &from->offset, (VkOffset2D*)(&to->offset));
+ deepcopy_VkExtent2D(pool, &from->extent, (VkExtent2D*)(&to->extent));
+}
+
+void deepcopy_VkPipelineViewportStateCreateInfo(
+ Pool* pool,
+ const VkPipelineViewportStateCreateInfo* from,
+ VkPipelineViewportStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pViewports = nullptr;
+ if (from->pViewports)
+ {
+ to->pViewports = (VkViewport*)pool->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));
+ }
+ }
+ to->pScissors = nullptr;
+ if (from->pScissors)
+ {
+ to->pScissors = (VkRect2D*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkPipelineRasterizationStateCreateInfo(
+ Pool* pool,
+ const VkPipelineRasterizationStateCreateInfo* from,
+ VkPipelineRasterizationStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineMultisampleStateCreateInfo(
+ Pool* pool,
+ const VkPipelineMultisampleStateCreateInfo* from,
+ VkPipelineMultisampleStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+ }
+}
+
+void deepcopy_VkStencilOpState(
+ Pool* pool,
+ const VkStencilOpState* from,
+ VkStencilOpState* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPipelineDepthStencilStateCreateInfo(
+ Pool* pool,
+ const VkPipelineDepthStencilStateCreateInfo* from,
+ VkPipelineDepthStencilStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkStencilOpState(pool, &from->front, (VkStencilOpState*)(&to->front));
+ deepcopy_VkStencilOpState(pool, &from->back, (VkStencilOpState*)(&to->back));
+}
+
+void deepcopy_VkPipelineColorBlendAttachmentState(
+ Pool* pool,
+ const VkPipelineColorBlendAttachmentState* from,
+ VkPipelineColorBlendAttachmentState* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPipelineColorBlendStateCreateInfo(
+ Pool* pool,
+ const VkPipelineColorBlendStateCreateInfo* from,
+ VkPipelineColorBlendStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttachments = nullptr;
+ if (from->pAttachments)
+ {
+ to->pAttachments = (VkPipelineColorBlendAttachmentState*)pool->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));
+ }
+ }
+ memcpy(to->blendConstants, from->blendConstants, 4 * sizeof(float));
+}
+
+void deepcopy_VkPipelineDynamicStateCreateInfo(
+ Pool* pool,
+ const VkPipelineDynamicStateCreateInfo* from,
+ VkPipelineDynamicStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pDynamicStates = nullptr;
+ if (from->pDynamicStates)
+ {
+ to->pDynamicStates = (VkDynamicState*)pool->dupArray(from->pDynamicStates, from->dynamicStateCount * sizeof(const VkDynamicState));
+ }
+}
+
+void deepcopy_VkGraphicsPipelineCreateInfo(
+ Pool* pool,
+ const VkGraphicsPipelineCreateInfo* from,
+ VkGraphicsPipelineCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pStages = nullptr;
+ if (from->pStages)
+ {
+ to->pStages = (VkPipelineShaderStageCreateInfo*)pool->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));
+ }
+ }
+ to->pVertexInputState = nullptr;
+ if (from->pVertexInputState)
+ {
+ to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)pool->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
+ deepcopy_VkPipelineVertexInputStateCreateInfo(pool, 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->pTessellationState = nullptr;
+ if (from->pTessellationState)
+ {
+ to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
+ deepcopy_VkPipelineTessellationStateCreateInfo(pool, 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->pRasterizationState = nullptr;
+ if (from->pRasterizationState)
+ {
+ to->pRasterizationState = (VkPipelineRasterizationStateCreateInfo*)pool->alloc(sizeof(const VkPipelineRasterizationStateCreateInfo));
+ deepcopy_VkPipelineRasterizationStateCreateInfo(pool, 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->pDepthStencilState = nullptr;
+ if (from->pDepthStencilState)
+ {
+ to->pDepthStencilState = (VkPipelineDepthStencilStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDepthStencilStateCreateInfo));
+ deepcopy_VkPipelineDepthStencilStateCreateInfo(pool, 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->pDynamicState = nullptr;
+ if (from->pDynamicState)
+ {
+ to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)pool->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
+ deepcopy_VkPipelineDynamicStateCreateInfo(pool, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
+ }
+}
+
+void deepcopy_VkComputePipelineCreateInfo(
+ Pool* pool,
+ const VkComputePipelineCreateInfo* from,
+ VkComputePipelineCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkPipelineShaderStageCreateInfo(pool, &from->stage, (VkPipelineShaderStageCreateInfo*)(&to->stage));
+}
+
+void deepcopy_VkPushConstantRange(
+ Pool* pool,
+ const VkPushConstantRange* from,
+ VkPushConstantRange* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPipelineLayoutCreateInfo(
+ Pool* pool,
+ const VkPipelineLayoutCreateInfo* from,
+ VkPipelineLayoutCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pSetLayouts = nullptr;
+ if (from->pSetLayouts)
+ {
+ to->pSetLayouts = (VkDescriptorSetLayout*)pool->dupArray(from->pSetLayouts, from->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+ }
+ to->pPushConstantRanges = nullptr;
+ if (from->pPushConstantRanges)
+ {
+ to->pPushConstantRanges = (VkPushConstantRange*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkSamplerCreateInfo(
+ Pool* pool,
+ const VkSamplerCreateInfo* from,
+ VkSamplerCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDescriptorSetLayoutBinding(
+ Pool* pool,
+ const VkDescriptorSetLayoutBinding* from,
+ VkDescriptorSetLayoutBinding* to)
+{
+ (void)pool;
+ *to = *from;
+ to->pImmutableSamplers = nullptr;
+ if (from->pImmutableSamplers)
+ {
+ to->pImmutableSamplers = (VkSampler*)pool->dupArray(from->pImmutableSamplers, from->descriptorCount * sizeof(const VkSampler));
+ }
+}
+
+void deepcopy_VkDescriptorSetLayoutCreateInfo(
+ Pool* pool,
+ const VkDescriptorSetLayoutCreateInfo* from,
+ VkDescriptorSetLayoutCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pBindings = nullptr;
+ if (from->pBindings)
+ {
+ to->pBindings = (VkDescriptorSetLayoutBinding*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkDescriptorPoolSize(
+ Pool* pool,
+ const VkDescriptorPoolSize* from,
+ VkDescriptorPoolSize* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkDescriptorPoolCreateInfo(
+ Pool* pool,
+ const VkDescriptorPoolCreateInfo* from,
+ VkDescriptorPoolCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pPoolSizes = nullptr;
+ if (from->pPoolSizes)
+ {
+ to->pPoolSizes = (VkDescriptorPoolSize*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkDescriptorSetAllocateInfo(
+ Pool* pool,
+ const VkDescriptorSetAllocateInfo* from,
+ VkDescriptorSetAllocateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pSetLayouts = nullptr;
+ if (from->pSetLayouts)
+ {
+ to->pSetLayouts = (VkDescriptorSetLayout*)pool->dupArray(from->pSetLayouts, from->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
+ }
+}
+
+void deepcopy_VkDescriptorImageInfo(
+ Pool* pool,
+ const VkDescriptorImageInfo* from,
+ VkDescriptorImageInfo* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkDescriptorBufferInfo(
+ Pool* pool,
+ const VkDescriptorBufferInfo* from,
+ VkDescriptorBufferInfo* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkWriteDescriptorSet(
+ Pool* pool,
+ const VkWriteDescriptorSet* from,
+ VkWriteDescriptorSet* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pImageInfo = nullptr;
+ if (from->pImageInfo)
+ {
+ to->pImageInfo = (VkDescriptorImageInfo*)pool->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));
+ }
+ }
+ to->pBufferInfo = nullptr;
+ if (from->pBufferInfo)
+ {
+ to->pBufferInfo = (VkDescriptorBufferInfo*)pool->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));
+ }
+ }
+ to->pTexelBufferView = nullptr;
+ if (from->pTexelBufferView)
+ {
+ to->pTexelBufferView = (VkBufferView*)pool->dupArray(from->pTexelBufferView, from->descriptorCount * sizeof(const VkBufferView));
+ }
+}
+
+void deepcopy_VkCopyDescriptorSet(
+ Pool* pool,
+ const VkCopyDescriptorSet* from,
+ VkCopyDescriptorSet* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkFramebufferCreateInfo(
+ Pool* pool,
+ const VkFramebufferCreateInfo* from,
+ VkFramebufferCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttachments = nullptr;
+ if (from->pAttachments)
+ {
+ to->pAttachments = (VkImageView*)pool->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
+ }
+}
+
+void deepcopy_VkAttachmentDescription(
+ Pool* pool,
+ const VkAttachmentDescription* from,
+ VkAttachmentDescription* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkAttachmentReference(
+ Pool* pool,
+ const VkAttachmentReference* from,
+ VkAttachmentReference* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkSubpassDescription(
+ Pool* pool,
+ const VkSubpassDescription* from,
+ VkSubpassDescription* to)
+{
+ (void)pool;
+ *to = *from;
+ to->pInputAttachments = nullptr;
+ if (from->pInputAttachments)
+ {
+ to->pInputAttachments = (VkAttachmentReference*)pool->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));
+ }
+ }
+ to->pColorAttachments = nullptr;
+ if (from->pColorAttachments)
+ {
+ to->pColorAttachments = (VkAttachmentReference*)pool->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));
+ }
+ }
+ to->pResolveAttachments = nullptr;
+ if (from->pResolveAttachments)
+ {
+ to->pResolveAttachments = (VkAttachmentReference*)pool->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));
+ }
+ }
+ to->pDepthStencilAttachment = nullptr;
+ if (from->pDepthStencilAttachment)
+ {
+ to->pDepthStencilAttachment = (VkAttachmentReference*)pool->alloc(sizeof(const VkAttachmentReference));
+ deepcopy_VkAttachmentReference(pool, 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));
+ }
+}
+
+void deepcopy_VkSubpassDependency(
+ Pool* pool,
+ const VkSubpassDependency* from,
+ VkSubpassDependency* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkRenderPassCreateInfo(
+ Pool* pool,
+ const VkRenderPassCreateInfo* from,
+ VkRenderPassCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttachments = nullptr;
+ if (from->pAttachments)
+ {
+ to->pAttachments = (VkAttachmentDescription*)pool->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));
+ }
+ }
+ to->pSubpasses = nullptr;
+ if (from->pSubpasses)
+ {
+ to->pSubpasses = (VkSubpassDescription*)pool->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));
+ }
+ }
+ to->pDependencies = nullptr;
+ if (from->pDependencies)
+ {
+ to->pDependencies = (VkSubpassDependency*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkCommandPoolCreateInfo(
+ Pool* pool,
+ const VkCommandPoolCreateInfo* from,
+ VkCommandPoolCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkCommandBufferAllocateInfo(
+ Pool* pool,
+ const VkCommandBufferAllocateInfo* from,
+ VkCommandBufferAllocateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkCommandBufferInheritanceInfo(
+ Pool* pool,
+ const VkCommandBufferInheritanceInfo* from,
+ VkCommandBufferInheritanceInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkCommandBufferBeginInfo(
+ Pool* pool,
+ const VkCommandBufferBeginInfo* from,
+ VkCommandBufferBeginInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+ }
+}
+
+void deepcopy_VkBufferCopy(
+ Pool* pool,
+ const VkBufferCopy* from,
+ VkBufferCopy* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkImageSubresourceLayers(
+ Pool* pool,
+ const VkImageSubresourceLayers* from,
+ VkImageSubresourceLayers* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkImageCopy(
+ Pool* pool,
+ const VkImageCopy* from,
+ VkImageCopy* to)
+{
+ (void)pool;
+ *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));
+}
+
+void deepcopy_VkImageBlit(
+ Pool* pool,
+ const VkImageBlit* from,
+ VkImageBlit* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkImageSubresourceLayers(pool, &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_VkImageSubresourceLayers(pool, &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));
+ }
+}
+
+void deepcopy_VkBufferImageCopy(
+ Pool* pool,
+ const VkBufferImageCopy* from,
+ VkBufferImageCopy* to)
+{
+ (void)pool;
+ *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));
+}
+
+void deepcopy_VkClearColorValue(
+ Pool* pool,
+ const VkClearColorValue* from,
+ VkClearColorValue* to)
+{
+ (void)pool;
+ *to = *from;
+ memcpy(to->float32, from->float32, 4 * sizeof(float));
+ memcpy(to->int32, from->int32, 4 * sizeof(int32_t));
+ memcpy(to->uint32, from->uint32, 4 * sizeof(uint32_t));
+}
+
+void deepcopy_VkClearDepthStencilValue(
+ Pool* pool,
+ const VkClearDepthStencilValue* from,
+ VkClearDepthStencilValue* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkClearValue(
+ Pool* pool,
+ const VkClearValue* from,
+ VkClearValue* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkClearColorValue(pool, &from->color, (VkClearColorValue*)(&to->color));
+ deepcopy_VkClearDepthStencilValue(pool, &from->depthStencil, (VkClearDepthStencilValue*)(&to->depthStencil));
+}
+
+void deepcopy_VkClearAttachment(
+ Pool* pool,
+ const VkClearAttachment* from,
+ VkClearAttachment* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkClearValue(pool, &from->clearValue, (VkClearValue*)(&to->clearValue));
+}
+
+void deepcopy_VkClearRect(
+ Pool* pool,
+ const VkClearRect* from,
+ VkClearRect* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkRect2D(pool, &from->rect, (VkRect2D*)(&to->rect));
+}
+
+void deepcopy_VkImageResolve(
+ Pool* pool,
+ const VkImageResolve* from,
+ VkImageResolve* to)
+{
+ (void)pool;
+ *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));
+}
+
+void deepcopy_VkMemoryBarrier(
+ Pool* pool,
+ const VkMemoryBarrier* from,
+ VkMemoryBarrier* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBufferMemoryBarrier(
+ Pool* pool,
+ const VkBufferMemoryBarrier* from,
+ VkBufferMemoryBarrier* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkImageMemoryBarrier(
+ Pool* pool,
+ const VkImageMemoryBarrier* from,
+ VkImageMemoryBarrier* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkImageSubresourceRange(pool, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
+}
+
+void deepcopy_VkRenderPassBeginInfo(
+ Pool* pool,
+ const VkRenderPassBeginInfo* from,
+ VkRenderPassBeginInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkRect2D(pool, &from->renderArea, (VkRect2D*)(&to->renderArea));
+ to->pClearValues = nullptr;
+ if (from->pClearValues)
+ {
+ to->pClearValues = (VkClearValue*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkDispatchIndirectCommand(
+ Pool* pool,
+ const VkDispatchIndirectCommand* from,
+ VkDispatchIndirectCommand* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkDrawIndexedIndirectCommand(
+ Pool* pool,
+ const VkDrawIndexedIndirectCommand* from,
+ VkDrawIndexedIndirectCommand* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkDrawIndirectCommand(
+ Pool* pool,
+ const VkDrawIndirectCommand* from,
+ VkDrawIndirectCommand* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkBaseOutStructure(
+ Pool* pool,
+ const VkBaseOutStructure* from,
+ VkBaseOutStructure* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (VkBaseOutStructure*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBaseInStructure(
+ Pool* pool,
+ const VkBaseInStructure* from,
+ VkBaseInStructure* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(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));
+ }
+}
+
+#endif
+#ifdef VK_VERSION_1_1
+void deepcopy_VkPhysicalDeviceSubgroupProperties(
+ Pool* pool,
+ const VkPhysicalDeviceSubgroupProperties* from,
+ VkPhysicalDeviceSubgroupProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBindBufferMemoryInfo(
+ Pool* pool,
+ const VkBindBufferMemoryInfo* from,
+ VkBindBufferMemoryInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBindImageMemoryInfo(
+ Pool* pool,
+ const VkBindImageMemoryInfo* from,
+ VkBindImageMemoryInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDevice16BitStorageFeatures(
+ Pool* pool,
+ const VkPhysicalDevice16BitStorageFeatures* from,
+ VkPhysicalDevice16BitStorageFeatures* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryDedicatedRequirements(
+ Pool* pool,
+ const VkMemoryDedicatedRequirements* from,
+ VkMemoryDedicatedRequirements* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryDedicatedAllocateInfo(
+ Pool* pool,
+ const VkMemoryDedicatedAllocateInfo* from,
+ VkMemoryDedicatedAllocateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryAllocateFlagsInfo(
+ Pool* pool,
+ const VkMemoryAllocateFlagsInfo* from,
+ VkMemoryAllocateFlagsInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDeviceGroupRenderPassBeginInfo(
+ Pool* pool,
+ const VkDeviceGroupRenderPassBeginInfo* from,
+ VkDeviceGroupRenderPassBeginInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pDeviceRenderAreas = nullptr;
+ if (from->pDeviceRenderAreas)
+ {
+ to->pDeviceRenderAreas = (VkRect2D*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
+ Pool* pool,
+ const VkDeviceGroupCommandBufferBeginInfo* from,
+ VkDeviceGroupCommandBufferBeginInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDeviceGroupSubmitInfo(
+ Pool* pool,
+ const VkDeviceGroupSubmitInfo* from,
+ VkDeviceGroupSubmitInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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->pCommandBufferDeviceMasks = nullptr;
+ if (from->pCommandBufferDeviceMasks)
+ {
+ to->pCommandBufferDeviceMasks = (uint32_t*)pool->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));
+ }
+}
+
+void deepcopy_VkDeviceGroupBindSparseInfo(
+ Pool* pool,
+ const VkDeviceGroupBindSparseInfo* from,
+ VkDeviceGroupBindSparseInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
+ Pool* pool,
+ const VkBindBufferMemoryDeviceGroupInfo* from,
+ VkBindBufferMemoryDeviceGroupInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+ }
+}
+
+void deepcopy_VkBindImageMemoryDeviceGroupInfo(
+ Pool* pool,
+ const VkBindImageMemoryDeviceGroupInfo* from,
+ VkBindImageMemoryDeviceGroupInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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->pSplitInstanceBindRegions = nullptr;
+ if (from->pSplitInstanceBindRegions)
+ {
+ to->pSplitInstanceBindRegions = (VkRect2D*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkPhysicalDeviceGroupProperties(
+ Pool* pool,
+ const VkPhysicalDeviceGroupProperties* from,
+ VkPhysicalDeviceGroupProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ memcpy(to->physicalDevices, from->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
+}
+
+void deepcopy_VkDeviceGroupDeviceCreateInfo(
+ Pool* pool,
+ const VkDeviceGroupDeviceCreateInfo* from,
+ VkDeviceGroupDeviceCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pPhysicalDevices = nullptr;
+ if (from->pPhysicalDevices)
+ {
+ to->pPhysicalDevices = (VkPhysicalDevice*)pool->dupArray(from->pPhysicalDevices, from->physicalDeviceCount * sizeof(const VkPhysicalDevice));
+ }
+}
+
+void deepcopy_VkBufferMemoryRequirementsInfo2(
+ Pool* pool,
+ const VkBufferMemoryRequirementsInfo2* from,
+ VkBufferMemoryRequirementsInfo2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkImageMemoryRequirementsInfo2(
+ Pool* pool,
+ const VkImageMemoryRequirementsInfo2* from,
+ VkImageMemoryRequirementsInfo2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkImageSparseMemoryRequirementsInfo2(
+ Pool* pool,
+ const VkImageSparseMemoryRequirementsInfo2* from,
+ VkImageSparseMemoryRequirementsInfo2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryRequirements2(
+ Pool* pool,
+ const VkMemoryRequirements2* from,
+ VkMemoryRequirements2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkMemoryRequirements(pool, &from->memoryRequirements, (VkMemoryRequirements*)(&to->memoryRequirements));
+}
+
+void deepcopy_VkSparseImageMemoryRequirements2(
+ Pool* pool,
+ const VkSparseImageMemoryRequirements2* from,
+ VkSparseImageMemoryRequirements2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkSparseImageMemoryRequirements(pool, &from->memoryRequirements, (VkSparseImageMemoryRequirements*)(&to->memoryRequirements));
+}
+
+void deepcopy_VkPhysicalDeviceFeatures2(
+ Pool* pool,
+ const VkPhysicalDeviceFeatures2* from,
+ VkPhysicalDeviceFeatures2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkPhysicalDeviceFeatures(pool, &from->features, (VkPhysicalDeviceFeatures*)(&to->features));
+}
+
+void deepcopy_VkPhysicalDeviceProperties2(
+ Pool* pool,
+ const VkPhysicalDeviceProperties2* from,
+ VkPhysicalDeviceProperties2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkPhysicalDeviceProperties(pool, &from->properties, (VkPhysicalDeviceProperties*)(&to->properties));
+}
+
+void deepcopy_VkFormatProperties2(
+ Pool* pool,
+ const VkFormatProperties2* from,
+ VkFormatProperties2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkFormatProperties(pool, &from->formatProperties, (VkFormatProperties*)(&to->formatProperties));
+}
+
+void deepcopy_VkImageFormatProperties2(
+ Pool* pool,
+ const VkImageFormatProperties2* from,
+ VkImageFormatProperties2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkImageFormatProperties(pool, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
+}
+
+void deepcopy_VkPhysicalDeviceImageFormatInfo2(
+ Pool* pool,
+ const VkPhysicalDeviceImageFormatInfo2* from,
+ VkPhysicalDeviceImageFormatInfo2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkQueueFamilyProperties2(
+ Pool* pool,
+ const VkQueueFamilyProperties2* from,
+ VkQueueFamilyProperties2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkQueueFamilyProperties(pool, &from->queueFamilyProperties, (VkQueueFamilyProperties*)(&to->queueFamilyProperties));
+}
+
+void deepcopy_VkPhysicalDeviceMemoryProperties2(
+ Pool* pool,
+ const VkPhysicalDeviceMemoryProperties2* from,
+ VkPhysicalDeviceMemoryProperties2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkPhysicalDeviceMemoryProperties(pool, &from->memoryProperties, (VkPhysicalDeviceMemoryProperties*)(&to->memoryProperties));
+}
+
+void deepcopy_VkSparseImageFormatProperties2(
+ Pool* pool,
+ const VkSparseImageFormatProperties2* from,
+ VkSparseImageFormatProperties2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkSparseImageFormatProperties(pool, &from->properties, (VkSparseImageFormatProperties*)(&to->properties));
+}
+
+void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
+ Pool* pool,
+ const VkPhysicalDeviceSparseImageFormatInfo2* from,
+ VkPhysicalDeviceSparseImageFormatInfo2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDevicePointClippingProperties(
+ Pool* pool,
+ const VkPhysicalDevicePointClippingProperties* from,
+ VkPhysicalDevicePointClippingProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkInputAttachmentAspectReference(
+ Pool* pool,
+ const VkInputAttachmentAspectReference* from,
+ VkInputAttachmentAspectReference* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
+ Pool* pool,
+ const VkRenderPassInputAttachmentAspectCreateInfo* from,
+ VkRenderPassInputAttachmentAspectCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAspectReferences = nullptr;
+ if (from->pAspectReferences)
+ {
+ to->pAspectReferences = (VkInputAttachmentAspectReference*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkImageViewUsageCreateInfo(
+ Pool* pool,
+ const VkImageViewUsageCreateInfo* from,
+ VkImageViewUsageCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
+ Pool* pool,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* from,
+ VkPipelineTessellationDomainOriginStateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkRenderPassMultiviewCreateInfo(
+ Pool* pool,
+ const VkRenderPassMultiviewCreateInfo* from,
+ VkRenderPassMultiviewCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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->pViewOffsets = nullptr;
+ if (from->pViewOffsets)
+ {
+ to->pViewOffsets = (int32_t*)pool->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));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceMultiviewFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceMultiviewFeatures* from,
+ VkPhysicalDeviceMultiviewFeatures* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceMultiviewProperties(
+ Pool* pool,
+ const VkPhysicalDeviceMultiviewProperties* from,
+ VkPhysicalDeviceMultiviewProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceVariablePointerFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceVariablePointerFeatures* from,
+ VkPhysicalDeviceVariablePointerFeatures* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceProtectedMemoryFeatures* from,
+ VkPhysicalDeviceProtectedMemoryFeatures* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
+ Pool* pool,
+ const VkPhysicalDeviceProtectedMemoryProperties* from,
+ VkPhysicalDeviceProtectedMemoryProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDeviceQueueInfo2(
+ Pool* pool,
+ const VkDeviceQueueInfo2* from,
+ VkDeviceQueueInfo2* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkProtectedSubmitInfo(
+ Pool* pool,
+ const VkProtectedSubmitInfo* from,
+ VkProtectedSubmitInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkSamplerYcbcrConversionCreateInfo(
+ Pool* pool,
+ const VkSamplerYcbcrConversionCreateInfo* from,
+ VkSamplerYcbcrConversionCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkComponentMapping(pool, &from->components, (VkComponentMapping*)(&to->components));
+}
+
+void deepcopy_VkSamplerYcbcrConversionInfo(
+ Pool* pool,
+ const VkSamplerYcbcrConversionInfo* from,
+ VkSamplerYcbcrConversionInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBindImagePlaneMemoryInfo(
+ Pool* pool,
+ const VkBindImagePlaneMemoryInfo* from,
+ VkBindImagePlaneMemoryInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkImagePlaneMemoryRequirementsInfo(
+ Pool* pool,
+ const VkImagePlaneMemoryRequirementsInfo* from,
+ VkImagePlaneMemoryRequirementsInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
+ Pool* pool,
+ const VkSamplerYcbcrConversionImageFormatProperties* from,
+ VkSamplerYcbcrConversionImageFormatProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDescriptorUpdateTemplateEntry(
+ Pool* pool,
+ const VkDescriptorUpdateTemplateEntry* from,
+ VkDescriptorUpdateTemplateEntry* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
+ Pool* pool,
+ const VkDescriptorUpdateTemplateCreateInfo* from,
+ VkDescriptorUpdateTemplateCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(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->pDescriptorUpdateEntries = nullptr;
+ if (from->pDescriptorUpdateEntries)
+ {
+ to->pDescriptorUpdateEntries = (VkDescriptorUpdateTemplateEntry*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkExternalMemoryProperties(
+ Pool* pool,
+ const VkExternalMemoryProperties* from,
+ VkExternalMemoryProperties* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
+ Pool* pool,
+ const VkPhysicalDeviceExternalImageFormatInfo* from,
+ VkPhysicalDeviceExternalImageFormatInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExternalImageFormatProperties(
+ Pool* pool,
+ const VkExternalImageFormatProperties* from,
+ VkExternalImageFormatProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkExternalMemoryProperties(pool, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
+}
+
+void deepcopy_VkPhysicalDeviceExternalBufferInfo(
+ Pool* pool,
+ const VkPhysicalDeviceExternalBufferInfo* from,
+ VkPhysicalDeviceExternalBufferInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExternalBufferProperties(
+ Pool* pool,
+ const VkExternalBufferProperties* from,
+ VkExternalBufferProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkExternalMemoryProperties(pool, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
+}
+
+void deepcopy_VkPhysicalDeviceIDProperties(
+ Pool* pool,
+ const VkPhysicalDeviceIDProperties* from,
+ VkPhysicalDeviceIDProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+ memcpy(to->deviceLUID, from->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
+}
+
+void deepcopy_VkExternalMemoryImageCreateInfo(
+ Pool* pool,
+ const VkExternalMemoryImageCreateInfo* from,
+ VkExternalMemoryImageCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExternalMemoryBufferCreateInfo(
+ Pool* pool,
+ const VkExternalMemoryBufferCreateInfo* from,
+ VkExternalMemoryBufferCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExportMemoryAllocateInfo(
+ Pool* pool,
+ const VkExportMemoryAllocateInfo* from,
+ VkExportMemoryAllocateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceExternalFenceInfo(
+ Pool* pool,
+ const VkPhysicalDeviceExternalFenceInfo* from,
+ VkPhysicalDeviceExternalFenceInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExternalFenceProperties(
+ Pool* pool,
+ const VkExternalFenceProperties* from,
+ VkExternalFenceProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExportFenceCreateInfo(
+ Pool* pool,
+ const VkExportFenceCreateInfo* from,
+ VkExportFenceCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExportSemaphoreCreateInfo(
+ Pool* pool,
+ const VkExportSemaphoreCreateInfo* from,
+ VkExportSemaphoreCreateInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
+ Pool* pool,
+ const VkPhysicalDeviceExternalSemaphoreInfo* from,
+ VkPhysicalDeviceExternalSemaphoreInfo* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExternalSemaphoreProperties(
+ Pool* pool,
+ const VkExternalSemaphoreProperties* from,
+ VkExternalSemaphoreProperties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance3Properties(
+ Pool* pool,
+ const VkPhysicalDeviceMaintenance3Properties* from,
+ VkPhysicalDeviceMaintenance3Properties* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDescriptorSetLayoutSupport(
+ Pool* pool,
+ const VkDescriptorSetLayoutSupport* from,
+ VkDescriptorSetLayoutSupport* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceShaderDrawParameterFeatures* from,
+ VkPhysicalDeviceShaderDrawParameterFeatures* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_surface
+void deepcopy_VkSurfaceCapabilitiesKHR(
+ Pool* pool,
+ const VkSurfaceCapabilitiesKHR* from,
+ VkSurfaceCapabilitiesKHR* to)
+{
+ (void)pool;
+ *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));
+}
+
+void deepcopy_VkSurfaceFormatKHR(
+ Pool* pool,
+ const VkSurfaceFormatKHR* from,
+ VkSurfaceFormatKHR* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+#endif
+#ifdef VK_KHR_swapchain
+void deepcopy_VkSwapchainCreateInfoKHR(
+ Pool* pool,
+ const VkSwapchainCreateInfoKHR* from,
+ VkSwapchainCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkExtent2D(pool, &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));
+ }
+}
+
+void deepcopy_VkPresentInfoKHR(
+ Pool* pool,
+ const VkPresentInfoKHR* from,
+ VkPresentInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pWaitSemaphores = nullptr;
+ if (from->pWaitSemaphores)
+ {
+ to->pWaitSemaphores = (VkSemaphore*)pool->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->pImageIndices = nullptr;
+ if (from->pImageIndices)
+ {
+ to->pImageIndices = (uint32_t*)pool->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));
+ }
+}
+
+void deepcopy_VkImageSwapchainCreateInfoKHR(
+ Pool* pool,
+ const VkImageSwapchainCreateInfoKHR* from,
+ VkImageSwapchainCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBindImageMemorySwapchainInfoKHR(
+ Pool* pool,
+ const VkBindImageMemorySwapchainInfoKHR* from,
+ VkBindImageMemorySwapchainInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkAcquireNextImageInfoKHR(
+ Pool* pool,
+ const VkAcquireNextImageInfoKHR* from,
+ VkAcquireNextImageInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
+ Pool* pool,
+ const VkDeviceGroupPresentCapabilitiesKHR* from,
+ VkDeviceGroupPresentCapabilitiesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ memcpy(to->presentMask, from->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
+}
+
+void deepcopy_VkDeviceGroupPresentInfoKHR(
+ Pool* pool,
+ const VkDeviceGroupPresentInfoKHR* from,
+ VkDeviceGroupPresentInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+ }
+}
+
+void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
+ Pool* pool,
+ const VkDeviceGroupSwapchainCreateInfoKHR* from,
+ VkDeviceGroupSwapchainCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_display
+void deepcopy_VkDisplayPropertiesKHR(
+ Pool* pool,
+ const VkDisplayPropertiesKHR* from,
+ VkDisplayPropertiesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ to->displayName = nullptr;
+ if (from->displayName)
+ {
+ to->displayName = pool->strDup(from->displayName);
+ }
+ deepcopy_VkExtent2D(pool, &from->physicalDimensions, (VkExtent2D*)(&to->physicalDimensions));
+ deepcopy_VkExtent2D(pool, &from->physicalResolution, (VkExtent2D*)(&to->physicalResolution));
+}
+
+void deepcopy_VkDisplayModeParametersKHR(
+ Pool* pool,
+ const VkDisplayModeParametersKHR* from,
+ VkDisplayModeParametersKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkExtent2D(pool, &from->visibleRegion, (VkExtent2D*)(&to->visibleRegion));
+}
+
+void deepcopy_VkDisplayModePropertiesKHR(
+ Pool* pool,
+ const VkDisplayModePropertiesKHR* from,
+ VkDisplayModePropertiesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkDisplayModeParametersKHR(pool, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
+}
+
+void deepcopy_VkDisplayModeCreateInfoKHR(
+ Pool* pool,
+ const VkDisplayModeCreateInfoKHR* from,
+ VkDisplayModeCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkDisplayModeParametersKHR(pool, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
+}
+
+void deepcopy_VkDisplayPlaneCapabilitiesKHR(
+ Pool* pool,
+ const VkDisplayPlaneCapabilitiesKHR* from,
+ VkDisplayPlaneCapabilitiesKHR* to)
+{
+ (void)pool;
+ *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));
+}
+
+void deepcopy_VkDisplayPlanePropertiesKHR(
+ Pool* pool,
+ const VkDisplayPlanePropertiesKHR* from,
+ VkDisplayPlanePropertiesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkDisplaySurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkDisplaySurfaceCreateInfoKHR* from,
+ VkDisplaySurfaceCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkExtent2D(pool, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
+}
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void deepcopy_VkDisplayPresentInfoKHR(
+ Pool* pool,
+ const VkDisplayPresentInfoKHR* from,
+ VkDisplayPresentInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkRect2D(pool, &from->srcRect, (VkRect2D*)(&to->srcRect));
+ deepcopy_VkRect2D(pool, &from->dstRect, (VkRect2D*)(&to->dstRect));
+}
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void deepcopy_VkXlibSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkXlibSurfaceCreateInfoKHR* from,
+ VkXlibSurfaceCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->dpy = nullptr;
+ if (from->dpy)
+ {
+ to->dpy = (Display*)pool->dupArray(from->dpy, sizeof(Display));
+ }
+}
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void deepcopy_VkXcbSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkXcbSurfaceCreateInfoKHR* from,
+ VkXcbSurfaceCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->connection = nullptr;
+ if (from->connection)
+ {
+ to->connection = (xcb_connection_t*)pool->dupArray(from->connection, sizeof(xcb_connection_t));
+ }
+}
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void deepcopy_VkWaylandSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkWaylandSurfaceCreateInfoKHR* from,
+ VkWaylandSurfaceCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->display = nullptr;
+ if (from->display)
+ {
+ to->display = (wl_display*)pool->dupArray(from->display, sizeof(wl_display));
+ }
+ to->surface = nullptr;
+ if (from->surface)
+ {
+ to->surface = (wl_surface*)pool->dupArray(from->surface, sizeof(wl_surface));
+ }
+}
+
+#endif
+#ifdef VK_KHR_mir_surface
+void deepcopy_VkMirSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkMirSurfaceCreateInfoKHR* from,
+ VkMirSurfaceCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->connection = nullptr;
+ if (from->connection)
+ {
+ to->connection = (MirConnection*)pool->dupArray(from->connection, sizeof(MirConnection));
+ }
+ to->mirSurface = nullptr;
+ if (from->mirSurface)
+ {
+ to->mirSurface = (MirSurface*)pool->dupArray(from->mirSurface, sizeof(MirSurface));
+ }
+}
+
+#endif
+#ifdef VK_KHR_android_surface
+void deepcopy_VkAndroidSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkAndroidSurfaceCreateInfoKHR* from,
+ VkAndroidSurfaceCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->window = nullptr;
+ if (from->window)
+ {
+ to->window = (ANativeWindow*)pool->dupArray(from->window, sizeof(ANativeWindow));
+ }
+}
+
+#endif
+#ifdef VK_KHR_win32_surface
+void deepcopy_VkWin32SurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkWin32SurfaceCreateInfoKHR* from,
+ VkWin32SurfaceCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void deepcopy_VkImportMemoryWin32HandleInfoKHR(
+ Pool* pool,
+ const VkImportMemoryWin32HandleInfoKHR* from,
+ VkImportMemoryWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExportMemoryWin32HandleInfoKHR(
+ Pool* pool,
+ const VkExportMemoryWin32HandleInfoKHR* from,
+ VkExportMemoryWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttributes = nullptr;
+ if (from->pAttributes)
+ {
+ to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+}
+
+void deepcopy_VkMemoryWin32HandlePropertiesKHR(
+ Pool* pool,
+ const VkMemoryWin32HandlePropertiesKHR* from,
+ VkMemoryWin32HandlePropertiesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryGetWin32HandleInfoKHR(
+ Pool* pool,
+ const VkMemoryGetWin32HandleInfoKHR* from,
+ VkMemoryGetWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void deepcopy_VkImportMemoryFdInfoKHR(
+ Pool* pool,
+ const VkImportMemoryFdInfoKHR* from,
+ VkImportMemoryFdInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryFdPropertiesKHR(
+ Pool* pool,
+ const VkMemoryFdPropertiesKHR* from,
+ VkMemoryFdPropertiesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryGetFdInfoKHR(
+ Pool* pool,
+ const VkMemoryGetFdInfoKHR* from,
+ VkMemoryGetFdInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ Pool* pool,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
+ VkWin32KeyedMutexAcquireReleaseInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAcquireSyncs = nullptr;
+ if (from->pAcquireSyncs)
+ {
+ to->pAcquireSyncs = (VkDeviceMemory*)pool->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->pAcquireTimeouts = nullptr;
+ if (from->pAcquireTimeouts)
+ {
+ to->pAcquireTimeouts = (uint32_t*)pool->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->pReleaseKeys = nullptr;
+ if (from->pReleaseKeys)
+ {
+ to->pReleaseKeys = (uint64_t*)pool->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
+ }
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
+ Pool* pool,
+ const VkImportSemaphoreWin32HandleInfoKHR* from,
+ VkImportSemaphoreWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
+ Pool* pool,
+ const VkExportSemaphoreWin32HandleInfoKHR* from,
+ VkExportSemaphoreWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttributes = nullptr;
+ if (from->pAttributes)
+ {
+ to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+}
+
+void deepcopy_VkD3D12FenceSubmitInfoKHR(
+ Pool* pool,
+ const VkD3D12FenceSubmitInfoKHR* from,
+ VkD3D12FenceSubmitInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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->pSignalSemaphoreValues = nullptr;
+ if (from->pSignalSemaphoreValues)
+ {
+ to->pSignalSemaphoreValues = (uint64_t*)pool->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ }
+}
+
+void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
+ Pool* pool,
+ const VkSemaphoreGetWin32HandleInfoKHR* from,
+ VkSemaphoreGetWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void deepcopy_VkImportSemaphoreFdInfoKHR(
+ Pool* pool,
+ const VkImportSemaphoreFdInfoKHR* from,
+ VkImportSemaphoreFdInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkSemaphoreGetFdInfoKHR(
+ Pool* pool,
+ const VkSemaphoreGetFdInfoKHR* from,
+ VkSemaphoreGetFdInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ Pool* pool,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
+ VkPhysicalDevicePushDescriptorPropertiesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void deepcopy_VkRectLayerKHR(
+ Pool* pool,
+ const VkRectLayerKHR* from,
+ VkRectLayerKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkOffset2D(pool, &from->offset, (VkOffset2D*)(&to->offset));
+ deepcopy_VkExtent2D(pool, &from->extent, (VkExtent2D*)(&to->extent));
+}
+
+void deepcopy_VkPresentRegionKHR(
+ Pool* pool,
+ const VkPresentRegionKHR* from,
+ VkPresentRegionKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ to->pRectangles = nullptr;
+ if (from->pRectangles)
+ {
+ to->pRectangles = (VkRectLayerKHR*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkPresentRegionsKHR(
+ Pool* pool,
+ const VkPresentRegionsKHR* from,
+ VkPresentRegionsKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pRegions = nullptr;
+ if (from->pRegions)
+ {
+ to->pRegions = (VkPresentRegionKHR*)pool->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));
+ }
+ }
+}
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void deepcopy_VkAttachmentDescription2KHR(
+ Pool* pool,
+ const VkAttachmentDescription2KHR* from,
+ VkAttachmentDescription2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkAttachmentReference2KHR(
+ Pool* pool,
+ const VkAttachmentReference2KHR* from,
+ VkAttachmentReference2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkSubpassDescription2KHR(
+ Pool* pool,
+ const VkSubpassDescription2KHR* from,
+ VkSubpassDescription2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pInputAttachments = nullptr;
+ if (from->pInputAttachments)
+ {
+ to->pInputAttachments = (VkAttachmentReference2KHR*)pool->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+ to->inputAttachmentCount = from->inputAttachmentCount;
+ for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i)
+ {
+ deepcopy_VkAttachmentReference2KHR(pool, from->pInputAttachments + i, (VkAttachmentReference2KHR*)(to->pInputAttachments + i));
+ }
+ }
+ to->pColorAttachments = nullptr;
+ if (from->pColorAttachments)
+ {
+ to->pColorAttachments = (VkAttachmentReference2KHR*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+ to->colorAttachmentCount = from->colorAttachmentCount;
+ for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
+ {
+ deepcopy_VkAttachmentReference2KHR(pool, from->pColorAttachments + i, (VkAttachmentReference2KHR*)(to->pColorAttachments + i));
+ }
+ }
+ to->pResolveAttachments = nullptr;
+ if (from->pResolveAttachments)
+ {
+ to->pResolveAttachments = (VkAttachmentReference2KHR*)pool->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+ to->colorAttachmentCount = from->colorAttachmentCount;
+ for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
+ {
+ deepcopy_VkAttachmentReference2KHR(pool, from->pResolveAttachments + i, (VkAttachmentReference2KHR*)(to->pResolveAttachments + i));
+ }
+ }
+ to->pDepthStencilAttachment = nullptr;
+ if (from->pDepthStencilAttachment)
+ {
+ to->pDepthStencilAttachment = (VkAttachmentReference2KHR*)pool->alloc(sizeof(const VkAttachmentReference2KHR));
+ deepcopy_VkAttachmentReference2KHR(pool, from->pDepthStencilAttachment, (VkAttachmentReference2KHR*)(to->pDepthStencilAttachment));
+ }
+ to->pPreserveAttachments = nullptr;
+ if (from->pPreserveAttachments)
+ {
+ to->pPreserveAttachments = (uint32_t*)pool->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
+ }
+}
+
+void deepcopy_VkSubpassDependency2KHR(
+ Pool* pool,
+ const VkSubpassDependency2KHR* from,
+ VkSubpassDependency2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkRenderPassCreateInfo2KHR(
+ Pool* pool,
+ const VkRenderPassCreateInfo2KHR* from,
+ VkRenderPassCreateInfo2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttachments = nullptr;
+ if (from->pAttachments)
+ {
+ to->pAttachments = (VkAttachmentDescription2KHR*)pool->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription2KHR));
+ to->attachmentCount = from->attachmentCount;
+ for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
+ {
+ deepcopy_VkAttachmentDescription2KHR(pool, from->pAttachments + i, (VkAttachmentDescription2KHR*)(to->pAttachments + i));
+ }
+ }
+ to->pSubpasses = nullptr;
+ if (from->pSubpasses)
+ {
+ to->pSubpasses = (VkSubpassDescription2KHR*)pool->alloc(from->subpassCount * sizeof(const VkSubpassDescription2KHR));
+ to->subpassCount = from->subpassCount;
+ for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i)
+ {
+ deepcopy_VkSubpassDescription2KHR(pool, from->pSubpasses + i, (VkSubpassDescription2KHR*)(to->pSubpasses + i));
+ }
+ }
+ to->pDependencies = nullptr;
+ if (from->pDependencies)
+ {
+ to->pDependencies = (VkSubpassDependency2KHR*)pool->alloc(from->dependencyCount * sizeof(const VkSubpassDependency2KHR));
+ to->dependencyCount = from->dependencyCount;
+ for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i)
+ {
+ deepcopy_VkSubpassDependency2KHR(pool, from->pDependencies + i, (VkSubpassDependency2KHR*)(to->pDependencies + i));
+ }
+ }
+ to->pCorrelatedViewMasks = nullptr;
+ if (from->pCorrelatedViewMasks)
+ {
+ to->pCorrelatedViewMasks = (uint32_t*)pool->dupArray(from->pCorrelatedViewMasks, from->correlatedViewMaskCount * sizeof(const uint32_t));
+ }
+}
+
+void deepcopy_VkSubpassBeginInfoKHR(
+ Pool* pool,
+ const VkSubpassBeginInfoKHR* from,
+ VkSubpassBeginInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkSubpassEndInfoKHR(
+ Pool* pool,
+ const VkSubpassEndInfoKHR* from,
+ VkSubpassEndInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
+ Pool* pool,
+ const VkSharedPresentSurfaceCapabilitiesKHR* from,
+ VkSharedPresentSurfaceCapabilitiesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void deepcopy_VkImportFenceWin32HandleInfoKHR(
+ Pool* pool,
+ const VkImportFenceWin32HandleInfoKHR* from,
+ VkImportFenceWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExportFenceWin32HandleInfoKHR(
+ Pool* pool,
+ const VkExportFenceWin32HandleInfoKHR* from,
+ VkExportFenceWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttributes = nullptr;
+ if (from->pAttributes)
+ {
+ to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+}
+
+void deepcopy_VkFenceGetWin32HandleInfoKHR(
+ Pool* pool,
+ const VkFenceGetWin32HandleInfoKHR* from,
+ VkFenceGetWin32HandleInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void deepcopy_VkImportFenceFdInfoKHR(
+ Pool* pool,
+ const VkImportFenceFdInfoKHR* from,
+ VkImportFenceFdInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkFenceGetFdInfoKHR(
+ Pool* pool,
+ const VkFenceGetFdInfoKHR* from,
+ VkFenceGetFdInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
+ Pool* pool,
+ const VkPhysicalDeviceSurfaceInfo2KHR* from,
+ VkPhysicalDeviceSurfaceInfo2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkSurfaceCapabilities2KHR(
+ Pool* pool,
+ const VkSurfaceCapabilities2KHR* from,
+ VkSurfaceCapabilities2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkSurfaceCapabilitiesKHR(pool, &from->surfaceCapabilities, (VkSurfaceCapabilitiesKHR*)(&to->surfaceCapabilities));
+}
+
+void deepcopy_VkSurfaceFormat2KHR(
+ Pool* pool,
+ const VkSurfaceFormat2KHR* from,
+ VkSurfaceFormat2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkSurfaceFormatKHR(pool, &from->surfaceFormat, (VkSurfaceFormatKHR*)(&to->surfaceFormat));
+}
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void deepcopy_VkDisplayProperties2KHR(
+ Pool* pool,
+ const VkDisplayProperties2KHR* from,
+ VkDisplayProperties2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkDisplayPropertiesKHR(pool, &from->displayProperties, (VkDisplayPropertiesKHR*)(&to->displayProperties));
+}
+
+void deepcopy_VkDisplayPlaneProperties2KHR(
+ Pool* pool,
+ const VkDisplayPlaneProperties2KHR* from,
+ VkDisplayPlaneProperties2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkDisplayPlanePropertiesKHR(pool, &from->displayPlaneProperties, (VkDisplayPlanePropertiesKHR*)(&to->displayPlaneProperties));
+}
+
+void deepcopy_VkDisplayModeProperties2KHR(
+ Pool* pool,
+ const VkDisplayModeProperties2KHR* from,
+ VkDisplayModeProperties2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkDisplayModePropertiesKHR(pool, &from->displayModeProperties, (VkDisplayModePropertiesKHR*)(&to->displayModeProperties));
+}
+
+void deepcopy_VkDisplayPlaneInfo2KHR(
+ Pool* pool,
+ const VkDisplayPlaneInfo2KHR* from,
+ VkDisplayPlaneInfo2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDisplayPlaneCapabilities2KHR(
+ Pool* pool,
+ const VkDisplayPlaneCapabilities2KHR* from,
+ VkDisplayPlaneCapabilities2KHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkDisplayPlaneCapabilitiesKHR(pool, &from->capabilities, (VkDisplayPlaneCapabilitiesKHR*)(&to->capabilities));
+}
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void deepcopy_VkImageFormatListCreateInfoKHR(
+ Pool* pool,
+ const VkImageFormatListCreateInfoKHR* from,
+ VkImageFormatListCreateInfoKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pViewFormats = nullptr;
+ if (from->pViewFormats)
+ {
+ to->pViewFormats = (VkFormat*)pool->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
+ }
+}
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(
+ Pool* pool,
+ const VkPhysicalDevice8BitStorageFeaturesKHR* from,
+ VkPhysicalDevice8BitStorageFeaturesKHR* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void deepcopy_VkNativeBufferANDROID(
+ Pool* pool,
+ const VkNativeBufferANDROID* from,
+ VkNativeBufferANDROID* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->handle = nullptr;
+ if (from->handle)
+ {
+ to->handle = (uint32_t*)pool->dupArray(from->handle, sizeof(const uint32_t));
+ }
+}
+
+#endif
+#ifdef VK_EXT_debug_report
+void deepcopy_VkDebugReportCallbackCreateInfoEXT(
+ Pool* pool,
+ const VkDebugReportCallbackCreateInfoEXT* from,
+ VkDebugReportCallbackCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pUserData = nullptr;
+ if (from->pUserData)
+ {
+ to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
+ Pool* pool,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* from,
+ VkPipelineRasterizationStateRasterizationOrderAMD* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void deepcopy_VkDebugMarkerObjectNameInfoEXT(
+ Pool* pool,
+ const VkDebugMarkerObjectNameInfoEXT* from,
+ VkDebugMarkerObjectNameInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pObjectName = nullptr;
+ if (from->pObjectName)
+ {
+ to->pObjectName = pool->strDup(from->pObjectName);
+ }
+}
+
+void deepcopy_VkDebugMarkerObjectTagInfoEXT(
+ Pool* pool,
+ const VkDebugMarkerObjectTagInfoEXT* from,
+ VkDebugMarkerObjectTagInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pTag = nullptr;
+ if (from->pTag)
+ {
+ to->pTag = (void*)pool->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
+ }
+}
+
+void deepcopy_VkDebugMarkerMarkerInfoEXT(
+ Pool* pool,
+ const VkDebugMarkerMarkerInfoEXT* from,
+ VkDebugMarkerMarkerInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pMarkerName = nullptr;
+ if (from->pMarkerName)
+ {
+ to->pMarkerName = pool->strDup(from->pMarkerName);
+ }
+ memcpy(to->color, from->color, 4 * sizeof(float));
+}
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
+ Pool* pool,
+ const VkDedicatedAllocationImageCreateInfoNV* from,
+ VkDedicatedAllocationImageCreateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
+ Pool* pool,
+ const VkDedicatedAllocationBufferCreateInfoNV* from,
+ VkDedicatedAllocationBufferCreateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
+ Pool* pool,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* from,
+ VkDedicatedAllocationMemoryAllocateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
+ Pool* pool,
+ const VkTextureLODGatherFormatPropertiesAMD* from,
+ VkTextureLODGatherFormatPropertiesAMD* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_shader_info
+void deepcopy_VkShaderResourceUsageAMD(
+ Pool* pool,
+ const VkShaderResourceUsageAMD* from,
+ VkShaderResourceUsageAMD* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkShaderStatisticsInfoAMD(
+ Pool* pool,
+ const VkShaderStatisticsInfoAMD* from,
+ VkShaderStatisticsInfoAMD* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkShaderResourceUsageAMD(pool, &from->resourceUsage, (VkShaderResourceUsageAMD*)(&to->resourceUsage));
+ memcpy(to->computeWorkGroupSize, from->computeWorkGroupSize, 3 * sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void deepcopy_VkExternalImageFormatPropertiesNV(
+ Pool* pool,
+ const VkExternalImageFormatPropertiesNV* from,
+ VkExternalImageFormatPropertiesNV* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkImageFormatProperties(pool, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
+}
+
+#endif
+#ifdef VK_NV_external_memory
+void deepcopy_VkExternalMemoryImageCreateInfoNV(
+ Pool* pool,
+ const VkExternalMemoryImageCreateInfoNV* from,
+ VkExternalMemoryImageCreateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExportMemoryAllocateInfoNV(
+ Pool* pool,
+ const VkExportMemoryAllocateInfoNV* from,
+ VkExportMemoryAllocateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void deepcopy_VkImportMemoryWin32HandleInfoNV(
+ Pool* pool,
+ const VkImportMemoryWin32HandleInfoNV* from,
+ VkImportMemoryWin32HandleInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExportMemoryWin32HandleInfoNV(
+ Pool* pool,
+ const VkExportMemoryWin32HandleInfoNV* from,
+ VkExportMemoryWin32HandleInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttributes = nullptr;
+ if (from->pAttributes)
+ {
+ to->pAttributes = (SECURITY_ATTRIBUTES*)pool->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+}
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ Pool* pool,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAcquireSyncs = nullptr;
+ if (from->pAcquireSyncs)
+ {
+ to->pAcquireSyncs = (VkDeviceMemory*)pool->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->pAcquireTimeoutMilliseconds = nullptr;
+ if (from->pAcquireTimeoutMilliseconds)
+ {
+ to->pAcquireTimeoutMilliseconds = (uint32_t*)pool->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->pReleaseKeys = nullptr;
+ if (from->pReleaseKeys)
+ {
+ to->pReleaseKeys = (uint64_t*)pool->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
+ }
+}
+
+#endif
+#ifdef VK_EXT_validation_flags
+void deepcopy_VkValidationFlagsEXT(
+ Pool* pool,
+ const VkValidationFlagsEXT* from,
+ VkValidationFlagsEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pDisabledValidationChecks = nullptr;
+ if (from->pDisabledValidationChecks)
+ {
+ to->pDisabledValidationChecks = (VkValidationCheckEXT*)pool->dupArray(from->pDisabledValidationChecks, from->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+ }
+}
+
+#endif
+#ifdef VK_NN_vi_surface
+void deepcopy_VkViSurfaceCreateInfoNN(
+ Pool* pool,
+ const VkViSurfaceCreateInfoNN* from,
+ VkViSurfaceCreateInfoNN* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->window = nullptr;
+ if (from->window)
+ {
+ to->window = (void*)pool->dupArray(from->window, sizeof(uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void deepcopy_VkConditionalRenderingBeginInfoEXT(
+ Pool* pool,
+ const VkConditionalRenderingBeginInfoEXT* from,
+ VkConditionalRenderingBeginInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ Pool* pool,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void deepcopy_VkDeviceGeneratedCommandsFeaturesNVX(
+ Pool* pool,
+ const VkDeviceGeneratedCommandsFeaturesNVX* from,
+ VkDeviceGeneratedCommandsFeaturesNVX* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDeviceGeneratedCommandsLimitsNVX(
+ Pool* pool,
+ const VkDeviceGeneratedCommandsLimitsNVX* from,
+ VkDeviceGeneratedCommandsLimitsNVX* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkIndirectCommandsTokenNVX(
+ Pool* pool,
+ const VkIndirectCommandsTokenNVX* from,
+ VkIndirectCommandsTokenNVX* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkIndirectCommandsLayoutTokenNVX(
+ Pool* pool,
+ const VkIndirectCommandsLayoutTokenNVX* from,
+ VkIndirectCommandsLayoutTokenNVX* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkIndirectCommandsLayoutCreateInfoNVX(
+ Pool* pool,
+ const VkIndirectCommandsLayoutCreateInfoNVX* from,
+ VkIndirectCommandsLayoutCreateInfoNVX* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pTokens = nullptr;
+ if (from->pTokens)
+ {
+ to->pTokens = (VkIndirectCommandsLayoutTokenNVX*)pool->alloc(from->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNVX));
+ to->tokenCount = from->tokenCount;
+ for (uint32_t i = 0; i < (uint32_t)from->tokenCount; ++i)
+ {
+ deepcopy_VkIndirectCommandsLayoutTokenNVX(pool, from->pTokens + i, (VkIndirectCommandsLayoutTokenNVX*)(to->pTokens + i));
+ }
+ }
+}
+
+void deepcopy_VkCmdProcessCommandsInfoNVX(
+ Pool* pool,
+ const VkCmdProcessCommandsInfoNVX* from,
+ VkCmdProcessCommandsInfoNVX* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pIndirectCommandsTokens = nullptr;
+ if (from->pIndirectCommandsTokens)
+ {
+ to->pIndirectCommandsTokens = (VkIndirectCommandsTokenNVX*)pool->alloc(from->indirectCommandsTokenCount * sizeof(const VkIndirectCommandsTokenNVX));
+ to->indirectCommandsTokenCount = from->indirectCommandsTokenCount;
+ for (uint32_t i = 0; i < (uint32_t)from->indirectCommandsTokenCount; ++i)
+ {
+ deepcopy_VkIndirectCommandsTokenNVX(pool, from->pIndirectCommandsTokens + i, (VkIndirectCommandsTokenNVX*)(to->pIndirectCommandsTokens + i));
+ }
+ }
+}
+
+void deepcopy_VkCmdReserveSpaceForCommandsInfoNVX(
+ Pool* pool,
+ const VkCmdReserveSpaceForCommandsInfoNVX* from,
+ VkCmdReserveSpaceForCommandsInfoNVX* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkObjectTableCreateInfoNVX(
+ Pool* pool,
+ const VkObjectTableCreateInfoNVX* from,
+ VkObjectTableCreateInfoNVX* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pObjectEntryTypes = nullptr;
+ if (from->pObjectEntryTypes)
+ {
+ to->pObjectEntryTypes = (VkObjectEntryTypeNVX*)pool->dupArray(from->pObjectEntryTypes, from->objectCount * sizeof(const VkObjectEntryTypeNVX));
+ }
+ to->pObjectEntryCounts = nullptr;
+ if (from->pObjectEntryCounts)
+ {
+ to->pObjectEntryCounts = (uint32_t*)pool->dupArray(from->pObjectEntryCounts, from->objectCount * sizeof(const uint32_t));
+ }
+ to->pObjectEntryUsageFlags = nullptr;
+ if (from->pObjectEntryUsageFlags)
+ {
+ to->pObjectEntryUsageFlags = (VkObjectEntryUsageFlagsNVX*)pool->dupArray(from->pObjectEntryUsageFlags, from->objectCount * sizeof(const VkObjectEntryUsageFlagsNVX));
+ }
+}
+
+void deepcopy_VkObjectTableEntryNVX(
+ Pool* pool,
+ const VkObjectTableEntryNVX* from,
+ VkObjectTableEntryNVX* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkObjectTablePipelineEntryNVX(
+ Pool* pool,
+ const VkObjectTablePipelineEntryNVX* from,
+ VkObjectTablePipelineEntryNVX* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkObjectTableDescriptorSetEntryNVX(
+ Pool* pool,
+ const VkObjectTableDescriptorSetEntryNVX* from,
+ VkObjectTableDescriptorSetEntryNVX* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkObjectTableVertexBufferEntryNVX(
+ Pool* pool,
+ const VkObjectTableVertexBufferEntryNVX* from,
+ VkObjectTableVertexBufferEntryNVX* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkObjectTableIndexBufferEntryNVX(
+ Pool* pool,
+ const VkObjectTableIndexBufferEntryNVX* from,
+ VkObjectTableIndexBufferEntryNVX* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkObjectTablePushConstantEntryNVX(
+ Pool* pool,
+ const VkObjectTablePushConstantEntryNVX* from,
+ VkObjectTablePushConstantEntryNVX* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void deepcopy_VkViewportWScalingNV(
+ Pool* pool,
+ const VkViewportWScalingNV* from,
+ VkViewportWScalingNV* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
+ Pool* pool,
+ const VkPipelineViewportWScalingStateCreateInfoNV* from,
+ VkPipelineViewportWScalingStateCreateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pViewportWScalings = nullptr;
+ if (from->pViewportWScalings)
+ {
+ to->pViewportWScalings = (VkViewportWScalingNV*)pool->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));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void deepcopy_VkSurfaceCapabilities2EXT(
+ Pool* pool,
+ const VkSurfaceCapabilities2EXT* from,
+ VkSurfaceCapabilities2EXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+}
+
+#endif
+#ifdef VK_EXT_display_control
+void deepcopy_VkDisplayPowerInfoEXT(
+ Pool* pool,
+ const VkDisplayPowerInfoEXT* from,
+ VkDisplayPowerInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDeviceEventInfoEXT(
+ Pool* pool,
+ const VkDeviceEventInfoEXT* from,
+ VkDeviceEventInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDisplayEventInfoEXT(
+ Pool* pool,
+ const VkDisplayEventInfoEXT* from,
+ VkDisplayEventInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkSwapchainCounterCreateInfoEXT(
+ Pool* pool,
+ const VkSwapchainCounterCreateInfoEXT* from,
+ VkSwapchainCounterCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void deepcopy_VkRefreshCycleDurationGOOGLE(
+ Pool* pool,
+ const VkRefreshCycleDurationGOOGLE* from,
+ VkRefreshCycleDurationGOOGLE* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPastPresentationTimingGOOGLE(
+ Pool* pool,
+ const VkPastPresentationTimingGOOGLE* from,
+ VkPastPresentationTimingGOOGLE* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPresentTimeGOOGLE(
+ Pool* pool,
+ const VkPresentTimeGOOGLE* from,
+ VkPresentTimeGOOGLE* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPresentTimesInfoGOOGLE(
+ Pool* pool,
+ const VkPresentTimesInfoGOOGLE* from,
+ VkPresentTimesInfoGOOGLE* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pTimes = nullptr;
+ if (from->pTimes)
+ {
+ to->pTimes = (VkPresentTimeGOOGLE*)pool->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));
+ }
+ }
+}
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ Pool* pool,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void deepcopy_VkViewportSwizzleNV(
+ Pool* pool,
+ const VkViewportSwizzleNV* from,
+ VkViewportSwizzleNV* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
+ Pool* pool,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* from,
+ VkPipelineViewportSwizzleStateCreateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pViewportSwizzles = nullptr;
+ if (from->pViewportSwizzles)
+ {
+ to->pViewportSwizzles = (VkViewportSwizzleNV*)pool->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));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
+ VkPipelineDiscardRectangleStateCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pDiscardRectangles = nullptr;
+ if (from->pDiscardRectangles)
+ {
+ to->pDiscardRectangles = (VkRect2D*)pool->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));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void deepcopy_VkXYColorEXT(
+ Pool* pool,
+ const VkXYColorEXT* from,
+ VkXYColorEXT* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkHdrMetadataEXT(
+ Pool* pool,
+ const VkHdrMetadataEXT* from,
+ VkHdrMetadataEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+}
+
+#endif
+#ifdef VK_MVK_ios_surface
+void deepcopy_VkIOSSurfaceCreateInfoMVK(
+ Pool* pool,
+ const VkIOSSurfaceCreateInfoMVK* from,
+ VkIOSSurfaceCreateInfoMVK* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pView = nullptr;
+ if (from->pView)
+ {
+ to->pView = (void*)pool->dupArray(from->pView, sizeof(const uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_MVK_macos_surface
+void deepcopy_VkMacOSSurfaceCreateInfoMVK(
+ Pool* pool,
+ const VkMacOSSurfaceCreateInfoMVK* from,
+ VkMacOSSurfaceCreateInfoMVK* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pView = nullptr;
+ if (from->pView)
+ {
+ to->pView = (void*)pool->dupArray(from->pView, sizeof(const uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void deepcopy_VkDebugUtilsObjectNameInfoEXT(
+ Pool* pool,
+ const VkDebugUtilsObjectNameInfoEXT* from,
+ VkDebugUtilsObjectNameInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pObjectName = nullptr;
+ if (from->pObjectName)
+ {
+ to->pObjectName = pool->strDup(from->pObjectName);
+ }
+}
+
+void deepcopy_VkDebugUtilsObjectTagInfoEXT(
+ Pool* pool,
+ const VkDebugUtilsObjectTagInfoEXT* from,
+ VkDebugUtilsObjectTagInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pTag = nullptr;
+ if (from->pTag)
+ {
+ to->pTag = (void*)pool->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
+ }
+}
+
+void deepcopy_VkDebugUtilsLabelEXT(
+ Pool* pool,
+ const VkDebugUtilsLabelEXT* from,
+ VkDebugUtilsLabelEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pLabelName = nullptr;
+ if (from->pLabelName)
+ {
+ to->pLabelName = pool->strDup(from->pLabelName);
+ }
+ memcpy(to->color, from->color, 4 * sizeof(float));
+}
+
+void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
+ Pool* pool,
+ const VkDebugUtilsMessengerCallbackDataEXT* from,
+ VkDebugUtilsMessengerCallbackDataEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pMessageIdName = nullptr;
+ if (from->pMessageIdName)
+ {
+ to->pMessageIdName = pool->strDup(from->pMessageIdName);
+ }
+ to->pMessage = nullptr;
+ if (from->pMessage)
+ {
+ to->pMessage = pool->strDup(from->pMessage);
+ }
+ to->pQueueLabels = nullptr;
+ if (from->pQueueLabels)
+ {
+ to->pQueueLabels = (VkDebugUtilsLabelEXT*)pool->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));
+ }
+ }
+ to->pCmdBufLabels = nullptr;
+ if (from->pCmdBufLabels)
+ {
+ to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)pool->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));
+ }
+ }
+ to->pObjects = nullptr;
+ if (from->pObjects)
+ {
+ to->pObjects = (VkDebugUtilsObjectNameInfoEXT*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
+ Pool* pool,
+ const VkDebugUtilsMessengerCreateInfoEXT* from,
+ VkDebugUtilsMessengerCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pUserData = nullptr;
+ if (from->pUserData)
+ {
+ to->pUserData = (void*)pool->dupArray(from->pUserData, sizeof(uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void deepcopy_VkAndroidHardwareBufferUsageANDROID(
+ Pool* pool,
+ const VkAndroidHardwareBufferUsageANDROID* from,
+ VkAndroidHardwareBufferUsageANDROID* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
+ Pool* pool,
+ const VkAndroidHardwareBufferPropertiesANDROID* from,
+ VkAndroidHardwareBufferPropertiesANDROID* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ Pool* pool,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
+ VkAndroidHardwareBufferFormatPropertiesANDROID* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkComponentMapping(pool, &from->samplerYcbcrConversionComponents, (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
+}
+
+void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
+ Pool* pool,
+ const VkImportAndroidHardwareBufferInfoANDROID* from,
+ VkImportAndroidHardwareBufferInfoANDROID* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->buffer = nullptr;
+ if (from->buffer)
+ {
+ to->buffer = (AHardwareBuffer*)pool->dupArray(from->buffer, sizeof(AHardwareBuffer));
+ }
+}
+
+void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ Pool* pool,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkExternalFormatANDROID(
+ Pool* pool,
+ const VkExternalFormatANDROID* from,
+ VkExternalFormatANDROID* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void deepcopy_VkSamplerReductionModeCreateInfoEXT(
+ Pool* pool,
+ const VkSamplerReductionModeCreateInfoEXT* from,
+ VkSamplerReductionModeCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* from,
+ VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void deepcopy_VkSampleLocationEXT(
+ Pool* pool,
+ const VkSampleLocationEXT* from,
+ VkSampleLocationEXT* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkSampleLocationsInfoEXT(
+ Pool* pool,
+ const VkSampleLocationsInfoEXT* from,
+ VkSampleLocationsInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkExtent2D(pool, &from->sampleLocationGridSize, (VkExtent2D*)(&to->sampleLocationGridSize));
+ to->pSampleLocations = nullptr;
+ if (from->pSampleLocations)
+ {
+ to->pSampleLocations = (VkSampleLocationEXT*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkAttachmentSampleLocationsEXT(
+ Pool* pool,
+ const VkAttachmentSampleLocationsEXT* from,
+ VkAttachmentSampleLocationsEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+}
+
+void deepcopy_VkSubpassSampleLocationsEXT(
+ Pool* pool,
+ const VkSubpassSampleLocationsEXT* from,
+ VkSubpassSampleLocationsEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+}
+
+void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
+ Pool* pool,
+ const VkRenderPassSampleLocationsBeginInfoEXT* from,
+ VkRenderPassSampleLocationsBeginInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pAttachmentInitialSampleLocations = nullptr;
+ if (from->pAttachmentInitialSampleLocations)
+ {
+ to->pAttachmentInitialSampleLocations = (VkAttachmentSampleLocationsEXT*)pool->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));
+ }
+ }
+ to->pPostSubpassSampleLocations = nullptr;
+ if (from->pPostSubpassSampleLocations)
+ {
+ to->pPostSubpassSampleLocations = (VkSubpassSampleLocationsEXT*)pool->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));
+ }
+ }
+}
+
+void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* from,
+ VkPipelineSampleLocationsStateCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkSampleLocationsInfoEXT(pool, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+}
+
+void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
+ VkPhysicalDeviceSampleLocationsPropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkExtent2D(pool, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
+ memcpy(to->sampleLocationCoordinateRange, from->sampleLocationCoordinateRange, 2 * sizeof(float));
+}
+
+void deepcopy_VkMultisamplePropertiesEXT(
+ Pool* pool,
+ const VkMultisamplePropertiesEXT* from,
+ VkMultisamplePropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkExtent2D(pool, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
+}
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
+ Pool* pool,
+ const VkPipelineCoverageToColorStateCreateInfoNV* from,
+ VkPipelineCoverageToColorStateCreateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
+ Pool* pool,
+ const VkPipelineCoverageModulationStateCreateInfoNV* from,
+ VkPipelineCoverageModulationStateCreateInfoNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pCoverageModulationTable = nullptr;
+ if (from->pCoverageModulationTable)
+ {
+ to->pCoverageModulationTable = (float*)pool->dupArray(from->pCoverageModulationTable, from->coverageModulationTableCount * sizeof(const float));
+ }
+}
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void deepcopy_VkValidationCacheCreateInfoEXT(
+ Pool* pool,
+ const VkValidationCacheCreateInfoEXT* from,
+ VkValidationCacheCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pInitialData = nullptr;
+ if (from->pInitialData)
+ {
+ to->pInitialData = (void*)pool->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
+ }
+}
+
+void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
+ Pool* pool,
+ const VkShaderModuleValidationCacheCreateInfoEXT* from,
+ VkShaderModuleValidationCacheCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+ Pool* pool,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* from,
+ VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pBindingFlags = nullptr;
+ if (from->pBindingFlags)
+ {
+ to->pBindingFlags = (VkDescriptorBindingFlagsEXT*)pool->dupArray(from->pBindingFlags, from->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* from,
+ VkPhysicalDeviceDescriptorIndexingFeaturesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* from,
+ VkPhysicalDeviceDescriptorIndexingPropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+ Pool* pool,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* from,
+ VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, 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));
+ }
+}
+
+void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+ Pool* pool,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* from,
+ VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ Pool* pool,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
+ VkDeviceQueueGlobalPriorityCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void deepcopy_VkImportMemoryHostPointerInfoEXT(
+ Pool* pool,
+ const VkImportMemoryHostPointerInfoEXT* from,
+ VkImportMemoryHostPointerInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pHostPointer = nullptr;
+ if (from->pHostPointer)
+ {
+ to->pHostPointer = (void*)pool->dupArray(from->pHostPointer, sizeof(uint8_t));
+ }
+}
+
+void deepcopy_VkMemoryHostPointerPropertiesEXT(
+ Pool* pool,
+ const VkMemoryHostPointerPropertiesEXT* from,
+ VkMemoryHostPointerPropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
+ Pool* pool,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* from,
+ VkPhysicalDeviceShaderCorePropertiesAMD* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
+ Pool* pool,
+ const VkVertexInputBindingDivisorDescriptionEXT* from,
+ VkVertexInputBindingDivisorDescriptionEXT* to)
+{
+ (void)pool;
+ *to = *from;
+}
+
+void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
+ VkPipelineVertexInputDivisorStateCreateInfoEXT* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (const void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+ to->pVertexBindingDivisors = nullptr;
+ if (from->pVertexBindingDivisors)
+ {
+ to->pVertexBindingDivisors = (VkVertexInputBindingDivisorDescriptionEXT*)pool->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));
+ }
+ }
+}
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
+ Pool* pool,
+ const VkQueueFamilyCheckpointPropertiesNV* from,
+ VkQueueFamilyCheckpointPropertiesNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(from->pNext);
+ to->pNext = nullptr;
+ if (pNext_size)
+ {
+ to->pNext = (void*)pool->alloc(pNext_size);
+ deepcopy_extension_struct(pool, from->pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkCheckpointDataNV(
+ Pool* pool,
+ const VkCheckpointDataNV* from,
+ VkCheckpointDataNV* to)
+{
+ (void)pool;
+ *to = *from;
+ size_t pNext_size = goldfish_vk_extension_struct_size(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->pCheckpointMarker = nullptr;
+ if (from->pCheckpointMarker)
+ {
+ to->pCheckpointMarker = (void*)pool->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
+ }
+}
+
+#endif
+void deepcopy_extension_struct(
+ Pool* pool,
+ const void* structExtension,
+ void* structExtension_out)
+{
+ if (!structExtension)
+ {
+ return;
+ }
+ uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
+ switch(structType)
+ {
+#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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+ {
+ deepcopy_VkPhysicalDevice16BitStorageFeatures(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+ {
+ deepcopy_VkMemoryDedicatedAllocateInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+ {
+ deepcopy_VkDeviceGroupRenderPassBeginInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+ {
+ deepcopy_VkDeviceGroupSubmitInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+ {
+ deepcopy_VkBindBufferMemoryDeviceGroupInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+ {
+ deepcopy_VkDeviceGroupDeviceCreateInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+ {
+ deepcopy_VkPhysicalDevicePointClippingProperties(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+ {
+ deepcopy_VkImageViewUsageCreateInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+ {
+ deepcopy_VkRenderPassMultiviewCreateInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+ {
+ deepcopy_VkPhysicalDeviceMultiviewProperties(pool, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+ {
+ deepcopy_VkPhysicalDeviceVariablePointerFeatures(pool, reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+ {
+ deepcopy_VkPhysicalDeviceProtectedMemoryProperties(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+ {
+ deepcopy_VkSamplerYcbcrConversionInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+ {
+ deepcopy_VkImagePlaneMemoryRequirementsInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+ {
+ deepcopy_VkSamplerYcbcrConversionImageFormatProperties(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+ {
+ deepcopy_VkExternalImageFormatProperties(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+ {
+ deepcopy_VkExternalMemoryImageCreateInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+ {
+ deepcopy_VkExportMemoryAllocateInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+ {
+ deepcopy_VkExportSemaphoreCreateInfo(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+ {
+ deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures(pool, reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+ {
+ deepcopy_VkBindImageMemorySwapchainInfoKHR(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+ {
+ deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(pool, 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ {
+ deepcopy_VkExportMemoryWin32HandleInfoKHR(pool, 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+ {
+ deepcopy_VkD3D12FenceSubmitInfoKHR(pool, 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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+#endif
+#ifdef VK_KHR_image_format_list
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+ {
+ deepcopy_VkImageFormatListCreateInfoKHR(pool, reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(structExtension), reinterpret_cast<VkImageFormatListCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_8bit_storage
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+ {
+ deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(pool, reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+ {
+ deepcopy_VkDedicatedAllocationBufferCreateInfoNV(pool, 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+ {
+ deepcopy_VkExportMemoryAllocateInfoNV(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ {
+ deepcopy_VkExportMemoryWin32HandleInfoNV(pool, 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+ {
+ deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(pool, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+ {
+ deepcopy_VkExternalFormatANDROID(pool, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+ {
+ deepcopy_VkSamplerReductionModeCreateInfoEXT(pool, reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(structExtension), reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+ {
+ deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+ {
+ deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(pool, 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+ {
+ deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(pool, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension), reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+ {
+ deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(pool, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+ {
+ deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(pool, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+ {
+ deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(pool, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+ {
+ deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(pool, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+#endif
+ default:
+ {
+ return;
+ }
+ }
+}
+
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
new file mode 100644
index 0000000..07828f5
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -0,0 +1,2012 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_deepcopy_guest
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "vk_platform_compat.h"
+
+#include "goldfish_vk_private_defs.h"
+#include "android/base/Pool.h"
+using android::base::Pool;
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+void deepcopy_VkApplicationInfo(
+ Pool* pool,
+ const VkApplicationInfo* from,
+ VkApplicationInfo* to);
+
+void deepcopy_VkInstanceCreateInfo(
+ Pool* pool,
+ const VkInstanceCreateInfo* from,
+ VkInstanceCreateInfo* to);
+
+void deepcopy_VkAllocationCallbacks(
+ Pool* pool,
+ const VkAllocationCallbacks* from,
+ VkAllocationCallbacks* to);
+
+void deepcopy_VkPhysicalDeviceFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceFeatures* from,
+ VkPhysicalDeviceFeatures* to);
+
+void deepcopy_VkFormatProperties(
+ Pool* pool,
+ const VkFormatProperties* from,
+ VkFormatProperties* to);
+
+void deepcopy_VkExtent3D(
+ Pool* pool,
+ const VkExtent3D* from,
+ VkExtent3D* to);
+
+void deepcopy_VkImageFormatProperties(
+ Pool* pool,
+ const VkImageFormatProperties* from,
+ VkImageFormatProperties* to);
+
+void deepcopy_VkPhysicalDeviceLimits(
+ Pool* pool,
+ const VkPhysicalDeviceLimits* from,
+ VkPhysicalDeviceLimits* to);
+
+void deepcopy_VkPhysicalDeviceSparseProperties(
+ Pool* pool,
+ const VkPhysicalDeviceSparseProperties* from,
+ VkPhysicalDeviceSparseProperties* to);
+
+void deepcopy_VkPhysicalDeviceProperties(
+ Pool* pool,
+ const VkPhysicalDeviceProperties* from,
+ VkPhysicalDeviceProperties* to);
+
+void deepcopy_VkQueueFamilyProperties(
+ Pool* pool,
+ const VkQueueFamilyProperties* from,
+ VkQueueFamilyProperties* to);
+
+void deepcopy_VkMemoryType(
+ Pool* pool,
+ const VkMemoryType* from,
+ VkMemoryType* to);
+
+void deepcopy_VkMemoryHeap(
+ Pool* pool,
+ const VkMemoryHeap* from,
+ VkMemoryHeap* to);
+
+void deepcopy_VkPhysicalDeviceMemoryProperties(
+ Pool* pool,
+ const VkPhysicalDeviceMemoryProperties* from,
+ VkPhysicalDeviceMemoryProperties* to);
+
+void deepcopy_VkDeviceQueueCreateInfo(
+ Pool* pool,
+ const VkDeviceQueueCreateInfo* from,
+ VkDeviceQueueCreateInfo* to);
+
+void deepcopy_VkDeviceCreateInfo(
+ Pool* pool,
+ const VkDeviceCreateInfo* from,
+ VkDeviceCreateInfo* to);
+
+void deepcopy_VkExtensionProperties(
+ Pool* pool,
+ const VkExtensionProperties* from,
+ VkExtensionProperties* to);
+
+void deepcopy_VkLayerProperties(
+ Pool* pool,
+ const VkLayerProperties* from,
+ VkLayerProperties* to);
+
+void deepcopy_VkSubmitInfo(
+ Pool* pool,
+ const VkSubmitInfo* from,
+ VkSubmitInfo* to);
+
+void deepcopy_VkMemoryAllocateInfo(
+ Pool* pool,
+ const VkMemoryAllocateInfo* from,
+ VkMemoryAllocateInfo* to);
+
+void deepcopy_VkMappedMemoryRange(
+ Pool* pool,
+ const VkMappedMemoryRange* from,
+ VkMappedMemoryRange* to);
+
+void deepcopy_VkMemoryRequirements(
+ Pool* pool,
+ const VkMemoryRequirements* from,
+ VkMemoryRequirements* to);
+
+void deepcopy_VkSparseImageFormatProperties(
+ Pool* pool,
+ const VkSparseImageFormatProperties* from,
+ VkSparseImageFormatProperties* to);
+
+void deepcopy_VkSparseImageMemoryRequirements(
+ Pool* pool,
+ const VkSparseImageMemoryRequirements* from,
+ VkSparseImageMemoryRequirements* to);
+
+void deepcopy_VkSparseMemoryBind(
+ Pool* pool,
+ const VkSparseMemoryBind* from,
+ VkSparseMemoryBind* to);
+
+void deepcopy_VkSparseBufferMemoryBindInfo(
+ Pool* pool,
+ const VkSparseBufferMemoryBindInfo* from,
+ VkSparseBufferMemoryBindInfo* to);
+
+void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
+ Pool* pool,
+ const VkSparseImageOpaqueMemoryBindInfo* from,
+ VkSparseImageOpaqueMemoryBindInfo* to);
+
+void deepcopy_VkImageSubresource(
+ Pool* pool,
+ const VkImageSubresource* from,
+ VkImageSubresource* to);
+
+void deepcopy_VkOffset3D(
+ Pool* pool,
+ const VkOffset3D* from,
+ VkOffset3D* to);
+
+void deepcopy_VkSparseImageMemoryBind(
+ Pool* pool,
+ const VkSparseImageMemoryBind* from,
+ VkSparseImageMemoryBind* to);
+
+void deepcopy_VkSparseImageMemoryBindInfo(
+ Pool* pool,
+ const VkSparseImageMemoryBindInfo* from,
+ VkSparseImageMemoryBindInfo* to);
+
+void deepcopy_VkBindSparseInfo(
+ Pool* pool,
+ const VkBindSparseInfo* from,
+ VkBindSparseInfo* to);
+
+void deepcopy_VkFenceCreateInfo(
+ Pool* pool,
+ const VkFenceCreateInfo* from,
+ VkFenceCreateInfo* to);
+
+void deepcopy_VkSemaphoreCreateInfo(
+ Pool* pool,
+ const VkSemaphoreCreateInfo* from,
+ VkSemaphoreCreateInfo* to);
+
+void deepcopy_VkEventCreateInfo(
+ Pool* pool,
+ const VkEventCreateInfo* from,
+ VkEventCreateInfo* to);
+
+void deepcopy_VkQueryPoolCreateInfo(
+ Pool* pool,
+ const VkQueryPoolCreateInfo* from,
+ VkQueryPoolCreateInfo* to);
+
+void deepcopy_VkBufferCreateInfo(
+ Pool* pool,
+ const VkBufferCreateInfo* from,
+ VkBufferCreateInfo* to);
+
+void deepcopy_VkBufferViewCreateInfo(
+ Pool* pool,
+ const VkBufferViewCreateInfo* from,
+ VkBufferViewCreateInfo* to);
+
+void deepcopy_VkImageCreateInfo(
+ Pool* pool,
+ const VkImageCreateInfo* from,
+ VkImageCreateInfo* to);
+
+void deepcopy_VkSubresourceLayout(
+ Pool* pool,
+ const VkSubresourceLayout* from,
+ VkSubresourceLayout* to);
+
+void deepcopy_VkComponentMapping(
+ Pool* pool,
+ const VkComponentMapping* from,
+ VkComponentMapping* to);
+
+void deepcopy_VkImageSubresourceRange(
+ Pool* pool,
+ const VkImageSubresourceRange* from,
+ VkImageSubresourceRange* to);
+
+void deepcopy_VkImageViewCreateInfo(
+ Pool* pool,
+ const VkImageViewCreateInfo* from,
+ VkImageViewCreateInfo* to);
+
+void deepcopy_VkShaderModuleCreateInfo(
+ Pool* pool,
+ const VkShaderModuleCreateInfo* from,
+ VkShaderModuleCreateInfo* to);
+
+void deepcopy_VkPipelineCacheCreateInfo(
+ Pool* pool,
+ const VkPipelineCacheCreateInfo* from,
+ VkPipelineCacheCreateInfo* to);
+
+void deepcopy_VkSpecializationMapEntry(
+ Pool* pool,
+ const VkSpecializationMapEntry* from,
+ VkSpecializationMapEntry* to);
+
+void deepcopy_VkSpecializationInfo(
+ Pool* pool,
+ const VkSpecializationInfo* from,
+ VkSpecializationInfo* to);
+
+void deepcopy_VkPipelineShaderStageCreateInfo(
+ Pool* pool,
+ const VkPipelineShaderStageCreateInfo* from,
+ VkPipelineShaderStageCreateInfo* to);
+
+void deepcopy_VkVertexInputBindingDescription(
+ Pool* pool,
+ const VkVertexInputBindingDescription* from,
+ VkVertexInputBindingDescription* to);
+
+void deepcopy_VkVertexInputAttributeDescription(
+ Pool* pool,
+ const VkVertexInputAttributeDescription* from,
+ VkVertexInputAttributeDescription* to);
+
+void deepcopy_VkPipelineVertexInputStateCreateInfo(
+ Pool* pool,
+ const VkPipelineVertexInputStateCreateInfo* from,
+ VkPipelineVertexInputStateCreateInfo* to);
+
+void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
+ Pool* pool,
+ const VkPipelineInputAssemblyStateCreateInfo* from,
+ VkPipelineInputAssemblyStateCreateInfo* to);
+
+void deepcopy_VkPipelineTessellationStateCreateInfo(
+ Pool* pool,
+ const VkPipelineTessellationStateCreateInfo* from,
+ VkPipelineTessellationStateCreateInfo* to);
+
+void deepcopy_VkViewport(
+ Pool* pool,
+ const VkViewport* from,
+ VkViewport* to);
+
+void deepcopy_VkOffset2D(
+ Pool* pool,
+ const VkOffset2D* from,
+ VkOffset2D* to);
+
+void deepcopy_VkExtent2D(
+ Pool* pool,
+ const VkExtent2D* from,
+ VkExtent2D* to);
+
+void deepcopy_VkRect2D(
+ Pool* pool,
+ const VkRect2D* from,
+ VkRect2D* to);
+
+void deepcopy_VkPipelineViewportStateCreateInfo(
+ Pool* pool,
+ const VkPipelineViewportStateCreateInfo* from,
+ VkPipelineViewportStateCreateInfo* to);
+
+void deepcopy_VkPipelineRasterizationStateCreateInfo(
+ Pool* pool,
+ const VkPipelineRasterizationStateCreateInfo* from,
+ VkPipelineRasterizationStateCreateInfo* to);
+
+void deepcopy_VkPipelineMultisampleStateCreateInfo(
+ Pool* pool,
+ const VkPipelineMultisampleStateCreateInfo* from,
+ VkPipelineMultisampleStateCreateInfo* to);
+
+void deepcopy_VkStencilOpState(
+ Pool* pool,
+ const VkStencilOpState* from,
+ VkStencilOpState* to);
+
+void deepcopy_VkPipelineDepthStencilStateCreateInfo(
+ Pool* pool,
+ const VkPipelineDepthStencilStateCreateInfo* from,
+ VkPipelineDepthStencilStateCreateInfo* to);
+
+void deepcopy_VkPipelineColorBlendAttachmentState(
+ Pool* pool,
+ const VkPipelineColorBlendAttachmentState* from,
+ VkPipelineColorBlendAttachmentState* to);
+
+void deepcopy_VkPipelineColorBlendStateCreateInfo(
+ Pool* pool,
+ const VkPipelineColorBlendStateCreateInfo* from,
+ VkPipelineColorBlendStateCreateInfo* to);
+
+void deepcopy_VkPipelineDynamicStateCreateInfo(
+ Pool* pool,
+ const VkPipelineDynamicStateCreateInfo* from,
+ VkPipelineDynamicStateCreateInfo* to);
+
+void deepcopy_VkGraphicsPipelineCreateInfo(
+ Pool* pool,
+ const VkGraphicsPipelineCreateInfo* from,
+ VkGraphicsPipelineCreateInfo* to);
+
+void deepcopy_VkComputePipelineCreateInfo(
+ Pool* pool,
+ const VkComputePipelineCreateInfo* from,
+ VkComputePipelineCreateInfo* to);
+
+void deepcopy_VkPushConstantRange(
+ Pool* pool,
+ const VkPushConstantRange* from,
+ VkPushConstantRange* to);
+
+void deepcopy_VkPipelineLayoutCreateInfo(
+ Pool* pool,
+ const VkPipelineLayoutCreateInfo* from,
+ VkPipelineLayoutCreateInfo* to);
+
+void deepcopy_VkSamplerCreateInfo(
+ Pool* pool,
+ const VkSamplerCreateInfo* from,
+ VkSamplerCreateInfo* to);
+
+void deepcopy_VkDescriptorSetLayoutBinding(
+ Pool* pool,
+ const VkDescriptorSetLayoutBinding* from,
+ VkDescriptorSetLayoutBinding* to);
+
+void deepcopy_VkDescriptorSetLayoutCreateInfo(
+ Pool* pool,
+ const VkDescriptorSetLayoutCreateInfo* from,
+ VkDescriptorSetLayoutCreateInfo* to);
+
+void deepcopy_VkDescriptorPoolSize(
+ Pool* pool,
+ const VkDescriptorPoolSize* from,
+ VkDescriptorPoolSize* to);
+
+void deepcopy_VkDescriptorPoolCreateInfo(
+ Pool* pool,
+ const VkDescriptorPoolCreateInfo* from,
+ VkDescriptorPoolCreateInfo* to);
+
+void deepcopy_VkDescriptorSetAllocateInfo(
+ Pool* pool,
+ const VkDescriptorSetAllocateInfo* from,
+ VkDescriptorSetAllocateInfo* to);
+
+void deepcopy_VkDescriptorImageInfo(
+ Pool* pool,
+ const VkDescriptorImageInfo* from,
+ VkDescriptorImageInfo* to);
+
+void deepcopy_VkDescriptorBufferInfo(
+ Pool* pool,
+ const VkDescriptorBufferInfo* from,
+ VkDescriptorBufferInfo* to);
+
+void deepcopy_VkWriteDescriptorSet(
+ Pool* pool,
+ const VkWriteDescriptorSet* from,
+ VkWriteDescriptorSet* to);
+
+void deepcopy_VkCopyDescriptorSet(
+ Pool* pool,
+ const VkCopyDescriptorSet* from,
+ VkCopyDescriptorSet* to);
+
+void deepcopy_VkFramebufferCreateInfo(
+ Pool* pool,
+ const VkFramebufferCreateInfo* from,
+ VkFramebufferCreateInfo* to);
+
+void deepcopy_VkAttachmentDescription(
+ Pool* pool,
+ const VkAttachmentDescription* from,
+ VkAttachmentDescription* to);
+
+void deepcopy_VkAttachmentReference(
+ Pool* pool,
+ const VkAttachmentReference* from,
+ VkAttachmentReference* to);
+
+void deepcopy_VkSubpassDescription(
+ Pool* pool,
+ const VkSubpassDescription* from,
+ VkSubpassDescription* to);
+
+void deepcopy_VkSubpassDependency(
+ Pool* pool,
+ const VkSubpassDependency* from,
+ VkSubpassDependency* to);
+
+void deepcopy_VkRenderPassCreateInfo(
+ Pool* pool,
+ const VkRenderPassCreateInfo* from,
+ VkRenderPassCreateInfo* to);
+
+void deepcopy_VkCommandPoolCreateInfo(
+ Pool* pool,
+ const VkCommandPoolCreateInfo* from,
+ VkCommandPoolCreateInfo* to);
+
+void deepcopy_VkCommandBufferAllocateInfo(
+ Pool* pool,
+ const VkCommandBufferAllocateInfo* from,
+ VkCommandBufferAllocateInfo* to);
+
+void deepcopy_VkCommandBufferInheritanceInfo(
+ Pool* pool,
+ const VkCommandBufferInheritanceInfo* from,
+ VkCommandBufferInheritanceInfo* to);
+
+void deepcopy_VkCommandBufferBeginInfo(
+ Pool* pool,
+ const VkCommandBufferBeginInfo* from,
+ VkCommandBufferBeginInfo* to);
+
+void deepcopy_VkBufferCopy(
+ Pool* pool,
+ const VkBufferCopy* from,
+ VkBufferCopy* to);
+
+void deepcopy_VkImageSubresourceLayers(
+ Pool* pool,
+ const VkImageSubresourceLayers* from,
+ VkImageSubresourceLayers* to);
+
+void deepcopy_VkImageCopy(
+ Pool* pool,
+ const VkImageCopy* from,
+ VkImageCopy* to);
+
+void deepcopy_VkImageBlit(
+ Pool* pool,
+ const VkImageBlit* from,
+ VkImageBlit* to);
+
+void deepcopy_VkBufferImageCopy(
+ Pool* pool,
+ const VkBufferImageCopy* from,
+ VkBufferImageCopy* to);
+
+void deepcopy_VkClearColorValue(
+ Pool* pool,
+ const VkClearColorValue* from,
+ VkClearColorValue* to);
+
+void deepcopy_VkClearDepthStencilValue(
+ Pool* pool,
+ const VkClearDepthStencilValue* from,
+ VkClearDepthStencilValue* to);
+
+void deepcopy_VkClearValue(
+ Pool* pool,
+ const VkClearValue* from,
+ VkClearValue* to);
+
+void deepcopy_VkClearAttachment(
+ Pool* pool,
+ const VkClearAttachment* from,
+ VkClearAttachment* to);
+
+void deepcopy_VkClearRect(
+ Pool* pool,
+ const VkClearRect* from,
+ VkClearRect* to);
+
+void deepcopy_VkImageResolve(
+ Pool* pool,
+ const VkImageResolve* from,
+ VkImageResolve* to);
+
+void deepcopy_VkMemoryBarrier(
+ Pool* pool,
+ const VkMemoryBarrier* from,
+ VkMemoryBarrier* to);
+
+void deepcopy_VkBufferMemoryBarrier(
+ Pool* pool,
+ const VkBufferMemoryBarrier* from,
+ VkBufferMemoryBarrier* to);
+
+void deepcopy_VkImageMemoryBarrier(
+ Pool* pool,
+ const VkImageMemoryBarrier* from,
+ VkImageMemoryBarrier* to);
+
+void deepcopy_VkRenderPassBeginInfo(
+ Pool* pool,
+ const VkRenderPassBeginInfo* from,
+ VkRenderPassBeginInfo* to);
+
+void deepcopy_VkDispatchIndirectCommand(
+ Pool* pool,
+ const VkDispatchIndirectCommand* from,
+ VkDispatchIndirectCommand* to);
+
+void deepcopy_VkDrawIndexedIndirectCommand(
+ Pool* pool,
+ const VkDrawIndexedIndirectCommand* from,
+ VkDrawIndexedIndirectCommand* to);
+
+void deepcopy_VkDrawIndirectCommand(
+ Pool* pool,
+ const VkDrawIndirectCommand* from,
+ VkDrawIndirectCommand* to);
+
+void deepcopy_VkBaseOutStructure(
+ Pool* pool,
+ const VkBaseOutStructure* from,
+ VkBaseOutStructure* to);
+
+void deepcopy_VkBaseInStructure(
+ Pool* pool,
+ const VkBaseInStructure* from,
+ VkBaseInStructure* to);
+
+#endif
+#ifdef VK_VERSION_1_1
+void deepcopy_VkPhysicalDeviceSubgroupProperties(
+ Pool* pool,
+ const VkPhysicalDeviceSubgroupProperties* from,
+ VkPhysicalDeviceSubgroupProperties* to);
+
+void deepcopy_VkBindBufferMemoryInfo(
+ Pool* pool,
+ const VkBindBufferMemoryInfo* from,
+ VkBindBufferMemoryInfo* to);
+
+void deepcopy_VkBindImageMemoryInfo(
+ Pool* pool,
+ const VkBindImageMemoryInfo* from,
+ VkBindImageMemoryInfo* to);
+
+void deepcopy_VkPhysicalDevice16BitStorageFeatures(
+ Pool* pool,
+ const VkPhysicalDevice16BitStorageFeatures* from,
+ VkPhysicalDevice16BitStorageFeatures* to);
+
+void deepcopy_VkMemoryDedicatedRequirements(
+ Pool* pool,
+ const VkMemoryDedicatedRequirements* from,
+ VkMemoryDedicatedRequirements* to);
+
+void deepcopy_VkMemoryDedicatedAllocateInfo(
+ Pool* pool,
+ const VkMemoryDedicatedAllocateInfo* from,
+ VkMemoryDedicatedAllocateInfo* to);
+
+void deepcopy_VkMemoryAllocateFlagsInfo(
+ Pool* pool,
+ const VkMemoryAllocateFlagsInfo* from,
+ VkMemoryAllocateFlagsInfo* to);
+
+void deepcopy_VkDeviceGroupRenderPassBeginInfo(
+ Pool* pool,
+ const VkDeviceGroupRenderPassBeginInfo* from,
+ VkDeviceGroupRenderPassBeginInfo* to);
+
+void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
+ Pool* pool,
+ const VkDeviceGroupCommandBufferBeginInfo* from,
+ VkDeviceGroupCommandBufferBeginInfo* to);
+
+void deepcopy_VkDeviceGroupSubmitInfo(
+ Pool* pool,
+ const VkDeviceGroupSubmitInfo* from,
+ VkDeviceGroupSubmitInfo* to);
+
+void deepcopy_VkDeviceGroupBindSparseInfo(
+ Pool* pool,
+ const VkDeviceGroupBindSparseInfo* from,
+ VkDeviceGroupBindSparseInfo* to);
+
+void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
+ Pool* pool,
+ const VkBindBufferMemoryDeviceGroupInfo* from,
+ VkBindBufferMemoryDeviceGroupInfo* to);
+
+void deepcopy_VkBindImageMemoryDeviceGroupInfo(
+ Pool* pool,
+ const VkBindImageMemoryDeviceGroupInfo* from,
+ VkBindImageMemoryDeviceGroupInfo* to);
+
+void deepcopy_VkPhysicalDeviceGroupProperties(
+ Pool* pool,
+ const VkPhysicalDeviceGroupProperties* from,
+ VkPhysicalDeviceGroupProperties* to);
+
+void deepcopy_VkDeviceGroupDeviceCreateInfo(
+ Pool* pool,
+ const VkDeviceGroupDeviceCreateInfo* from,
+ VkDeviceGroupDeviceCreateInfo* to);
+
+void deepcopy_VkBufferMemoryRequirementsInfo2(
+ Pool* pool,
+ const VkBufferMemoryRequirementsInfo2* from,
+ VkBufferMemoryRequirementsInfo2* to);
+
+void deepcopy_VkImageMemoryRequirementsInfo2(
+ Pool* pool,
+ const VkImageMemoryRequirementsInfo2* from,
+ VkImageMemoryRequirementsInfo2* to);
+
+void deepcopy_VkImageSparseMemoryRequirementsInfo2(
+ Pool* pool,
+ const VkImageSparseMemoryRequirementsInfo2* from,
+ VkImageSparseMemoryRequirementsInfo2* to);
+
+void deepcopy_VkMemoryRequirements2(
+ Pool* pool,
+ const VkMemoryRequirements2* from,
+ VkMemoryRequirements2* to);
+
+void deepcopy_VkSparseImageMemoryRequirements2(
+ Pool* pool,
+ const VkSparseImageMemoryRequirements2* from,
+ VkSparseImageMemoryRequirements2* to);
+
+void deepcopy_VkPhysicalDeviceFeatures2(
+ Pool* pool,
+ const VkPhysicalDeviceFeatures2* from,
+ VkPhysicalDeviceFeatures2* to);
+
+void deepcopy_VkPhysicalDeviceProperties2(
+ Pool* pool,
+ const VkPhysicalDeviceProperties2* from,
+ VkPhysicalDeviceProperties2* to);
+
+void deepcopy_VkFormatProperties2(
+ Pool* pool,
+ const VkFormatProperties2* from,
+ VkFormatProperties2* to);
+
+void deepcopy_VkImageFormatProperties2(
+ Pool* pool,
+ const VkImageFormatProperties2* from,
+ VkImageFormatProperties2* to);
+
+void deepcopy_VkPhysicalDeviceImageFormatInfo2(
+ Pool* pool,
+ const VkPhysicalDeviceImageFormatInfo2* from,
+ VkPhysicalDeviceImageFormatInfo2* to);
+
+void deepcopy_VkQueueFamilyProperties2(
+ Pool* pool,
+ const VkQueueFamilyProperties2* from,
+ VkQueueFamilyProperties2* to);
+
+void deepcopy_VkPhysicalDeviceMemoryProperties2(
+ Pool* pool,
+ const VkPhysicalDeviceMemoryProperties2* from,
+ VkPhysicalDeviceMemoryProperties2* to);
+
+void deepcopy_VkSparseImageFormatProperties2(
+ Pool* pool,
+ const VkSparseImageFormatProperties2* from,
+ VkSparseImageFormatProperties2* to);
+
+void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
+ Pool* pool,
+ const VkPhysicalDeviceSparseImageFormatInfo2* from,
+ VkPhysicalDeviceSparseImageFormatInfo2* to);
+
+void deepcopy_VkPhysicalDevicePointClippingProperties(
+ Pool* pool,
+ const VkPhysicalDevicePointClippingProperties* from,
+ VkPhysicalDevicePointClippingProperties* to);
+
+void deepcopy_VkInputAttachmentAspectReference(
+ Pool* pool,
+ const VkInputAttachmentAspectReference* from,
+ VkInputAttachmentAspectReference* to);
+
+void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
+ Pool* pool,
+ const VkRenderPassInputAttachmentAspectCreateInfo* from,
+ VkRenderPassInputAttachmentAspectCreateInfo* to);
+
+void deepcopy_VkImageViewUsageCreateInfo(
+ Pool* pool,
+ const VkImageViewUsageCreateInfo* from,
+ VkImageViewUsageCreateInfo* to);
+
+void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
+ Pool* pool,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* from,
+ VkPipelineTessellationDomainOriginStateCreateInfo* to);
+
+void deepcopy_VkRenderPassMultiviewCreateInfo(
+ Pool* pool,
+ const VkRenderPassMultiviewCreateInfo* from,
+ VkRenderPassMultiviewCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceMultiviewFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceMultiviewFeatures* from,
+ VkPhysicalDeviceMultiviewFeatures* to);
+
+void deepcopy_VkPhysicalDeviceMultiviewProperties(
+ Pool* pool,
+ const VkPhysicalDeviceMultiviewProperties* from,
+ VkPhysicalDeviceMultiviewProperties* to);
+
+void deepcopy_VkPhysicalDeviceVariablePointerFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceVariablePointerFeatures* from,
+ VkPhysicalDeviceVariablePointerFeatures* to);
+
+void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceProtectedMemoryFeatures* from,
+ VkPhysicalDeviceProtectedMemoryFeatures* to);
+
+void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
+ Pool* pool,
+ const VkPhysicalDeviceProtectedMemoryProperties* from,
+ VkPhysicalDeviceProtectedMemoryProperties* to);
+
+void deepcopy_VkDeviceQueueInfo2(
+ Pool* pool,
+ const VkDeviceQueueInfo2* from,
+ VkDeviceQueueInfo2* to);
+
+void deepcopy_VkProtectedSubmitInfo(
+ Pool* pool,
+ const VkProtectedSubmitInfo* from,
+ VkProtectedSubmitInfo* to);
+
+void deepcopy_VkSamplerYcbcrConversionCreateInfo(
+ Pool* pool,
+ const VkSamplerYcbcrConversionCreateInfo* from,
+ VkSamplerYcbcrConversionCreateInfo* to);
+
+void deepcopy_VkSamplerYcbcrConversionInfo(
+ Pool* pool,
+ const VkSamplerYcbcrConversionInfo* from,
+ VkSamplerYcbcrConversionInfo* to);
+
+void deepcopy_VkBindImagePlaneMemoryInfo(
+ Pool* pool,
+ const VkBindImagePlaneMemoryInfo* from,
+ VkBindImagePlaneMemoryInfo* to);
+
+void deepcopy_VkImagePlaneMemoryRequirementsInfo(
+ Pool* pool,
+ const VkImagePlaneMemoryRequirementsInfo* from,
+ VkImagePlaneMemoryRequirementsInfo* to);
+
+void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* to);
+
+void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
+ Pool* pool,
+ const VkSamplerYcbcrConversionImageFormatProperties* from,
+ VkSamplerYcbcrConversionImageFormatProperties* to);
+
+void deepcopy_VkDescriptorUpdateTemplateEntry(
+ Pool* pool,
+ const VkDescriptorUpdateTemplateEntry* from,
+ VkDescriptorUpdateTemplateEntry* to);
+
+void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
+ Pool* pool,
+ const VkDescriptorUpdateTemplateCreateInfo* from,
+ VkDescriptorUpdateTemplateCreateInfo* to);
+
+void deepcopy_VkExternalMemoryProperties(
+ Pool* pool,
+ const VkExternalMemoryProperties* from,
+ VkExternalMemoryProperties* to);
+
+void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
+ Pool* pool,
+ const VkPhysicalDeviceExternalImageFormatInfo* from,
+ VkPhysicalDeviceExternalImageFormatInfo* to);
+
+void deepcopy_VkExternalImageFormatProperties(
+ Pool* pool,
+ const VkExternalImageFormatProperties* from,
+ VkExternalImageFormatProperties* to);
+
+void deepcopy_VkPhysicalDeviceExternalBufferInfo(
+ Pool* pool,
+ const VkPhysicalDeviceExternalBufferInfo* from,
+ VkPhysicalDeviceExternalBufferInfo* to);
+
+void deepcopy_VkExternalBufferProperties(
+ Pool* pool,
+ const VkExternalBufferProperties* from,
+ VkExternalBufferProperties* to);
+
+void deepcopy_VkPhysicalDeviceIDProperties(
+ Pool* pool,
+ const VkPhysicalDeviceIDProperties* from,
+ VkPhysicalDeviceIDProperties* to);
+
+void deepcopy_VkExternalMemoryImageCreateInfo(
+ Pool* pool,
+ const VkExternalMemoryImageCreateInfo* from,
+ VkExternalMemoryImageCreateInfo* to);
+
+void deepcopy_VkExternalMemoryBufferCreateInfo(
+ Pool* pool,
+ const VkExternalMemoryBufferCreateInfo* from,
+ VkExternalMemoryBufferCreateInfo* to);
+
+void deepcopy_VkExportMemoryAllocateInfo(
+ Pool* pool,
+ const VkExportMemoryAllocateInfo* from,
+ VkExportMemoryAllocateInfo* to);
+
+void deepcopy_VkPhysicalDeviceExternalFenceInfo(
+ Pool* pool,
+ const VkPhysicalDeviceExternalFenceInfo* from,
+ VkPhysicalDeviceExternalFenceInfo* to);
+
+void deepcopy_VkExternalFenceProperties(
+ Pool* pool,
+ const VkExternalFenceProperties* from,
+ VkExternalFenceProperties* to);
+
+void deepcopy_VkExportFenceCreateInfo(
+ Pool* pool,
+ const VkExportFenceCreateInfo* from,
+ VkExportFenceCreateInfo* to);
+
+void deepcopy_VkExportSemaphoreCreateInfo(
+ Pool* pool,
+ const VkExportSemaphoreCreateInfo* from,
+ VkExportSemaphoreCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
+ Pool* pool,
+ const VkPhysicalDeviceExternalSemaphoreInfo* from,
+ VkPhysicalDeviceExternalSemaphoreInfo* to);
+
+void deepcopy_VkExternalSemaphoreProperties(
+ Pool* pool,
+ const VkExternalSemaphoreProperties* from,
+ VkExternalSemaphoreProperties* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance3Properties(
+ Pool* pool,
+ const VkPhysicalDeviceMaintenance3Properties* from,
+ VkPhysicalDeviceMaintenance3Properties* to);
+
+void deepcopy_VkDescriptorSetLayoutSupport(
+ Pool* pool,
+ const VkDescriptorSetLayoutSupport* from,
+ VkDescriptorSetLayoutSupport* to);
+
+void deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures(
+ Pool* pool,
+ const VkPhysicalDeviceShaderDrawParameterFeatures* from,
+ VkPhysicalDeviceShaderDrawParameterFeatures* to);
+
+#endif
+#ifdef VK_KHR_surface
+void deepcopy_VkSurfaceCapabilitiesKHR(
+ Pool* pool,
+ const VkSurfaceCapabilitiesKHR* from,
+ VkSurfaceCapabilitiesKHR* to);
+
+void deepcopy_VkSurfaceFormatKHR(
+ Pool* pool,
+ const VkSurfaceFormatKHR* from,
+ VkSurfaceFormatKHR* to);
+
+#endif
+#ifdef VK_KHR_swapchain
+void deepcopy_VkSwapchainCreateInfoKHR(
+ Pool* pool,
+ const VkSwapchainCreateInfoKHR* from,
+ VkSwapchainCreateInfoKHR* to);
+
+void deepcopy_VkPresentInfoKHR(
+ Pool* pool,
+ const VkPresentInfoKHR* from,
+ VkPresentInfoKHR* to);
+
+void deepcopy_VkImageSwapchainCreateInfoKHR(
+ Pool* pool,
+ const VkImageSwapchainCreateInfoKHR* from,
+ VkImageSwapchainCreateInfoKHR* to);
+
+void deepcopy_VkBindImageMemorySwapchainInfoKHR(
+ Pool* pool,
+ const VkBindImageMemorySwapchainInfoKHR* from,
+ VkBindImageMemorySwapchainInfoKHR* to);
+
+void deepcopy_VkAcquireNextImageInfoKHR(
+ Pool* pool,
+ const VkAcquireNextImageInfoKHR* from,
+ VkAcquireNextImageInfoKHR* to);
+
+void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
+ Pool* pool,
+ const VkDeviceGroupPresentCapabilitiesKHR* from,
+ VkDeviceGroupPresentCapabilitiesKHR* to);
+
+void deepcopy_VkDeviceGroupPresentInfoKHR(
+ Pool* pool,
+ const VkDeviceGroupPresentInfoKHR* from,
+ VkDeviceGroupPresentInfoKHR* to);
+
+void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
+ Pool* pool,
+ const VkDeviceGroupSwapchainCreateInfoKHR* from,
+ VkDeviceGroupSwapchainCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_display
+void deepcopy_VkDisplayPropertiesKHR(
+ Pool* pool,
+ const VkDisplayPropertiesKHR* from,
+ VkDisplayPropertiesKHR* to);
+
+void deepcopy_VkDisplayModeParametersKHR(
+ Pool* pool,
+ const VkDisplayModeParametersKHR* from,
+ VkDisplayModeParametersKHR* to);
+
+void deepcopy_VkDisplayModePropertiesKHR(
+ Pool* pool,
+ const VkDisplayModePropertiesKHR* from,
+ VkDisplayModePropertiesKHR* to);
+
+void deepcopy_VkDisplayModeCreateInfoKHR(
+ Pool* pool,
+ const VkDisplayModeCreateInfoKHR* from,
+ VkDisplayModeCreateInfoKHR* to);
+
+void deepcopy_VkDisplayPlaneCapabilitiesKHR(
+ Pool* pool,
+ const VkDisplayPlaneCapabilitiesKHR* from,
+ VkDisplayPlaneCapabilitiesKHR* to);
+
+void deepcopy_VkDisplayPlanePropertiesKHR(
+ Pool* pool,
+ const VkDisplayPlanePropertiesKHR* from,
+ VkDisplayPlanePropertiesKHR* to);
+
+void deepcopy_VkDisplaySurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkDisplaySurfaceCreateInfoKHR* from,
+ VkDisplaySurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void deepcopy_VkDisplayPresentInfoKHR(
+ Pool* pool,
+ const VkDisplayPresentInfoKHR* from,
+ VkDisplayPresentInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void deepcopy_VkXlibSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkXlibSurfaceCreateInfoKHR* from,
+ VkXlibSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void deepcopy_VkXcbSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkXcbSurfaceCreateInfoKHR* from,
+ VkXcbSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void deepcopy_VkWaylandSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkWaylandSurfaceCreateInfoKHR* from,
+ VkWaylandSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_mir_surface
+void deepcopy_VkMirSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkMirSurfaceCreateInfoKHR* from,
+ VkMirSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_android_surface
+void deepcopy_VkAndroidSurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkAndroidSurfaceCreateInfoKHR* from,
+ VkAndroidSurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_win32_surface
+void deepcopy_VkWin32SurfaceCreateInfoKHR(
+ Pool* pool,
+ const VkWin32SurfaceCreateInfoKHR* from,
+ VkWin32SurfaceCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void deepcopy_VkImportMemoryWin32HandleInfoKHR(
+ Pool* pool,
+ const VkImportMemoryWin32HandleInfoKHR* from,
+ VkImportMemoryWin32HandleInfoKHR* to);
+
+void deepcopy_VkExportMemoryWin32HandleInfoKHR(
+ Pool* pool,
+ const VkExportMemoryWin32HandleInfoKHR* from,
+ VkExportMemoryWin32HandleInfoKHR* to);
+
+void deepcopy_VkMemoryWin32HandlePropertiesKHR(
+ Pool* pool,
+ const VkMemoryWin32HandlePropertiesKHR* from,
+ VkMemoryWin32HandlePropertiesKHR* to);
+
+void deepcopy_VkMemoryGetWin32HandleInfoKHR(
+ Pool* pool,
+ const VkMemoryGetWin32HandleInfoKHR* from,
+ VkMemoryGetWin32HandleInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void deepcopy_VkImportMemoryFdInfoKHR(
+ Pool* pool,
+ const VkImportMemoryFdInfoKHR* from,
+ VkImportMemoryFdInfoKHR* to);
+
+void deepcopy_VkMemoryFdPropertiesKHR(
+ Pool* pool,
+ const VkMemoryFdPropertiesKHR* from,
+ VkMemoryFdPropertiesKHR* to);
+
+void deepcopy_VkMemoryGetFdInfoKHR(
+ Pool* pool,
+ const VkMemoryGetFdInfoKHR* from,
+ VkMemoryGetFdInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ Pool* pool,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
+ VkWin32KeyedMutexAcquireReleaseInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
+ Pool* pool,
+ const VkImportSemaphoreWin32HandleInfoKHR* from,
+ VkImportSemaphoreWin32HandleInfoKHR* to);
+
+void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
+ Pool* pool,
+ const VkExportSemaphoreWin32HandleInfoKHR* from,
+ VkExportSemaphoreWin32HandleInfoKHR* to);
+
+void deepcopy_VkD3D12FenceSubmitInfoKHR(
+ Pool* pool,
+ const VkD3D12FenceSubmitInfoKHR* from,
+ VkD3D12FenceSubmitInfoKHR* to);
+
+void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
+ Pool* pool,
+ const VkSemaphoreGetWin32HandleInfoKHR* from,
+ VkSemaphoreGetWin32HandleInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void deepcopy_VkImportSemaphoreFdInfoKHR(
+ Pool* pool,
+ const VkImportSemaphoreFdInfoKHR* from,
+ VkImportSemaphoreFdInfoKHR* to);
+
+void deepcopy_VkSemaphoreGetFdInfoKHR(
+ Pool* pool,
+ const VkSemaphoreGetFdInfoKHR* from,
+ VkSemaphoreGetFdInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ Pool* pool,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
+ VkPhysicalDevicePushDescriptorPropertiesKHR* to);
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void deepcopy_VkRectLayerKHR(
+ Pool* pool,
+ const VkRectLayerKHR* from,
+ VkRectLayerKHR* to);
+
+void deepcopy_VkPresentRegionKHR(
+ Pool* pool,
+ const VkPresentRegionKHR* from,
+ VkPresentRegionKHR* to);
+
+void deepcopy_VkPresentRegionsKHR(
+ Pool* pool,
+ const VkPresentRegionsKHR* from,
+ VkPresentRegionsKHR* to);
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void deepcopy_VkAttachmentDescription2KHR(
+ Pool* pool,
+ const VkAttachmentDescription2KHR* from,
+ VkAttachmentDescription2KHR* to);
+
+void deepcopy_VkAttachmentReference2KHR(
+ Pool* pool,
+ const VkAttachmentReference2KHR* from,
+ VkAttachmentReference2KHR* to);
+
+void deepcopy_VkSubpassDescription2KHR(
+ Pool* pool,
+ const VkSubpassDescription2KHR* from,
+ VkSubpassDescription2KHR* to);
+
+void deepcopy_VkSubpassDependency2KHR(
+ Pool* pool,
+ const VkSubpassDependency2KHR* from,
+ VkSubpassDependency2KHR* to);
+
+void deepcopy_VkRenderPassCreateInfo2KHR(
+ Pool* pool,
+ const VkRenderPassCreateInfo2KHR* from,
+ VkRenderPassCreateInfo2KHR* to);
+
+void deepcopy_VkSubpassBeginInfoKHR(
+ Pool* pool,
+ const VkSubpassBeginInfoKHR* from,
+ VkSubpassBeginInfoKHR* to);
+
+void deepcopy_VkSubpassEndInfoKHR(
+ Pool* pool,
+ const VkSubpassEndInfoKHR* from,
+ VkSubpassEndInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
+ Pool* pool,
+ const VkSharedPresentSurfaceCapabilitiesKHR* from,
+ VkSharedPresentSurfaceCapabilitiesKHR* to);
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void deepcopy_VkImportFenceWin32HandleInfoKHR(
+ Pool* pool,
+ const VkImportFenceWin32HandleInfoKHR* from,
+ VkImportFenceWin32HandleInfoKHR* to);
+
+void deepcopy_VkExportFenceWin32HandleInfoKHR(
+ Pool* pool,
+ const VkExportFenceWin32HandleInfoKHR* from,
+ VkExportFenceWin32HandleInfoKHR* to);
+
+void deepcopy_VkFenceGetWin32HandleInfoKHR(
+ Pool* pool,
+ const VkFenceGetWin32HandleInfoKHR* from,
+ VkFenceGetWin32HandleInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void deepcopy_VkImportFenceFdInfoKHR(
+ Pool* pool,
+ const VkImportFenceFdInfoKHR* from,
+ VkImportFenceFdInfoKHR* to);
+
+void deepcopy_VkFenceGetFdInfoKHR(
+ Pool* pool,
+ const VkFenceGetFdInfoKHR* from,
+ VkFenceGetFdInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
+ Pool* pool,
+ const VkPhysicalDeviceSurfaceInfo2KHR* from,
+ VkPhysicalDeviceSurfaceInfo2KHR* to);
+
+void deepcopy_VkSurfaceCapabilities2KHR(
+ Pool* pool,
+ const VkSurfaceCapabilities2KHR* from,
+ VkSurfaceCapabilities2KHR* to);
+
+void deepcopy_VkSurfaceFormat2KHR(
+ Pool* pool,
+ const VkSurfaceFormat2KHR* from,
+ VkSurfaceFormat2KHR* to);
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void deepcopy_VkDisplayProperties2KHR(
+ Pool* pool,
+ const VkDisplayProperties2KHR* from,
+ VkDisplayProperties2KHR* to);
+
+void deepcopy_VkDisplayPlaneProperties2KHR(
+ Pool* pool,
+ const VkDisplayPlaneProperties2KHR* from,
+ VkDisplayPlaneProperties2KHR* to);
+
+void deepcopy_VkDisplayModeProperties2KHR(
+ Pool* pool,
+ const VkDisplayModeProperties2KHR* from,
+ VkDisplayModeProperties2KHR* to);
+
+void deepcopy_VkDisplayPlaneInfo2KHR(
+ Pool* pool,
+ const VkDisplayPlaneInfo2KHR* from,
+ VkDisplayPlaneInfo2KHR* to);
+
+void deepcopy_VkDisplayPlaneCapabilities2KHR(
+ Pool* pool,
+ const VkDisplayPlaneCapabilities2KHR* from,
+ VkDisplayPlaneCapabilities2KHR* to);
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void deepcopy_VkImageFormatListCreateInfoKHR(
+ Pool* pool,
+ const VkImageFormatListCreateInfoKHR* from,
+ VkImageFormatListCreateInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR(
+ Pool* pool,
+ const VkPhysicalDevice8BitStorageFeaturesKHR* from,
+ VkPhysicalDevice8BitStorageFeaturesKHR* to);
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void deepcopy_VkNativeBufferANDROID(
+ Pool* pool,
+ const VkNativeBufferANDROID* from,
+ VkNativeBufferANDROID* to);
+
+#endif
+#ifdef VK_EXT_debug_report
+void deepcopy_VkDebugReportCallbackCreateInfoEXT(
+ Pool* pool,
+ const VkDebugReportCallbackCreateInfoEXT* from,
+ VkDebugReportCallbackCreateInfoEXT* to);
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
+ Pool* pool,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* from,
+ VkPipelineRasterizationStateRasterizationOrderAMD* to);
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void deepcopy_VkDebugMarkerObjectNameInfoEXT(
+ Pool* pool,
+ const VkDebugMarkerObjectNameInfoEXT* from,
+ VkDebugMarkerObjectNameInfoEXT* to);
+
+void deepcopy_VkDebugMarkerObjectTagInfoEXT(
+ Pool* pool,
+ const VkDebugMarkerObjectTagInfoEXT* from,
+ VkDebugMarkerObjectTagInfoEXT* to);
+
+void deepcopy_VkDebugMarkerMarkerInfoEXT(
+ Pool* pool,
+ const VkDebugMarkerMarkerInfoEXT* from,
+ VkDebugMarkerMarkerInfoEXT* to);
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
+ Pool* pool,
+ const VkDedicatedAllocationImageCreateInfoNV* from,
+ VkDedicatedAllocationImageCreateInfoNV* to);
+
+void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
+ Pool* pool,
+ const VkDedicatedAllocationBufferCreateInfoNV* from,
+ VkDedicatedAllocationBufferCreateInfoNV* to);
+
+void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
+ Pool* pool,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* from,
+ VkDedicatedAllocationMemoryAllocateInfoNV* to);
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
+ Pool* pool,
+ const VkTextureLODGatherFormatPropertiesAMD* from,
+ VkTextureLODGatherFormatPropertiesAMD* to);
+
+#endif
+#ifdef VK_AMD_shader_info
+void deepcopy_VkShaderResourceUsageAMD(
+ Pool* pool,
+ const VkShaderResourceUsageAMD* from,
+ VkShaderResourceUsageAMD* to);
+
+void deepcopy_VkShaderStatisticsInfoAMD(
+ Pool* pool,
+ const VkShaderStatisticsInfoAMD* from,
+ VkShaderStatisticsInfoAMD* to);
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void deepcopy_VkExternalImageFormatPropertiesNV(
+ Pool* pool,
+ const VkExternalImageFormatPropertiesNV* from,
+ VkExternalImageFormatPropertiesNV* to);
+
+#endif
+#ifdef VK_NV_external_memory
+void deepcopy_VkExternalMemoryImageCreateInfoNV(
+ Pool* pool,
+ const VkExternalMemoryImageCreateInfoNV* from,
+ VkExternalMemoryImageCreateInfoNV* to);
+
+void deepcopy_VkExportMemoryAllocateInfoNV(
+ Pool* pool,
+ const VkExportMemoryAllocateInfoNV* from,
+ VkExportMemoryAllocateInfoNV* to);
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void deepcopy_VkImportMemoryWin32HandleInfoNV(
+ Pool* pool,
+ const VkImportMemoryWin32HandleInfoNV* from,
+ VkImportMemoryWin32HandleInfoNV* to);
+
+void deepcopy_VkExportMemoryWin32HandleInfoNV(
+ Pool* pool,
+ const VkExportMemoryWin32HandleInfoNV* from,
+ VkExportMemoryWin32HandleInfoNV* to);
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ Pool* pool,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* to);
+
+#endif
+#ifdef VK_EXT_validation_flags
+void deepcopy_VkValidationFlagsEXT(
+ Pool* pool,
+ const VkValidationFlagsEXT* from,
+ VkValidationFlagsEXT* to);
+
+#endif
+#ifdef VK_NN_vi_surface
+void deepcopy_VkViSurfaceCreateInfoNN(
+ Pool* pool,
+ const VkViSurfaceCreateInfoNN* from,
+ VkViSurfaceCreateInfoNN* to);
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void deepcopy_VkConditionalRenderingBeginInfoEXT(
+ Pool* pool,
+ const VkConditionalRenderingBeginInfoEXT* from,
+ VkConditionalRenderingBeginInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* to);
+
+void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ Pool* pool,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* to);
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void deepcopy_VkDeviceGeneratedCommandsFeaturesNVX(
+ Pool* pool,
+ const VkDeviceGeneratedCommandsFeaturesNVX* from,
+ VkDeviceGeneratedCommandsFeaturesNVX* to);
+
+void deepcopy_VkDeviceGeneratedCommandsLimitsNVX(
+ Pool* pool,
+ const VkDeviceGeneratedCommandsLimitsNVX* from,
+ VkDeviceGeneratedCommandsLimitsNVX* to);
+
+void deepcopy_VkIndirectCommandsTokenNVX(
+ Pool* pool,
+ const VkIndirectCommandsTokenNVX* from,
+ VkIndirectCommandsTokenNVX* to);
+
+void deepcopy_VkIndirectCommandsLayoutTokenNVX(
+ Pool* pool,
+ const VkIndirectCommandsLayoutTokenNVX* from,
+ VkIndirectCommandsLayoutTokenNVX* to);
+
+void deepcopy_VkIndirectCommandsLayoutCreateInfoNVX(
+ Pool* pool,
+ const VkIndirectCommandsLayoutCreateInfoNVX* from,
+ VkIndirectCommandsLayoutCreateInfoNVX* to);
+
+void deepcopy_VkCmdProcessCommandsInfoNVX(
+ Pool* pool,
+ const VkCmdProcessCommandsInfoNVX* from,
+ VkCmdProcessCommandsInfoNVX* to);
+
+void deepcopy_VkCmdReserveSpaceForCommandsInfoNVX(
+ Pool* pool,
+ const VkCmdReserveSpaceForCommandsInfoNVX* from,
+ VkCmdReserveSpaceForCommandsInfoNVX* to);
+
+void deepcopy_VkObjectTableCreateInfoNVX(
+ Pool* pool,
+ const VkObjectTableCreateInfoNVX* from,
+ VkObjectTableCreateInfoNVX* to);
+
+void deepcopy_VkObjectTableEntryNVX(
+ Pool* pool,
+ const VkObjectTableEntryNVX* from,
+ VkObjectTableEntryNVX* to);
+
+void deepcopy_VkObjectTablePipelineEntryNVX(
+ Pool* pool,
+ const VkObjectTablePipelineEntryNVX* from,
+ VkObjectTablePipelineEntryNVX* to);
+
+void deepcopy_VkObjectTableDescriptorSetEntryNVX(
+ Pool* pool,
+ const VkObjectTableDescriptorSetEntryNVX* from,
+ VkObjectTableDescriptorSetEntryNVX* to);
+
+void deepcopy_VkObjectTableVertexBufferEntryNVX(
+ Pool* pool,
+ const VkObjectTableVertexBufferEntryNVX* from,
+ VkObjectTableVertexBufferEntryNVX* to);
+
+void deepcopy_VkObjectTableIndexBufferEntryNVX(
+ Pool* pool,
+ const VkObjectTableIndexBufferEntryNVX* from,
+ VkObjectTableIndexBufferEntryNVX* to);
+
+void deepcopy_VkObjectTablePushConstantEntryNVX(
+ Pool* pool,
+ const VkObjectTablePushConstantEntryNVX* from,
+ VkObjectTablePushConstantEntryNVX* to);
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void deepcopy_VkViewportWScalingNV(
+ Pool* pool,
+ const VkViewportWScalingNV* from,
+ VkViewportWScalingNV* to);
+
+void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
+ Pool* pool,
+ const VkPipelineViewportWScalingStateCreateInfoNV* from,
+ VkPipelineViewportWScalingStateCreateInfoNV* to);
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void deepcopy_VkSurfaceCapabilities2EXT(
+ Pool* pool,
+ const VkSurfaceCapabilities2EXT* from,
+ VkSurfaceCapabilities2EXT* to);
+
+#endif
+#ifdef VK_EXT_display_control
+void deepcopy_VkDisplayPowerInfoEXT(
+ Pool* pool,
+ const VkDisplayPowerInfoEXT* from,
+ VkDisplayPowerInfoEXT* to);
+
+void deepcopy_VkDeviceEventInfoEXT(
+ Pool* pool,
+ const VkDeviceEventInfoEXT* from,
+ VkDeviceEventInfoEXT* to);
+
+void deepcopy_VkDisplayEventInfoEXT(
+ Pool* pool,
+ const VkDisplayEventInfoEXT* from,
+ VkDisplayEventInfoEXT* to);
+
+void deepcopy_VkSwapchainCounterCreateInfoEXT(
+ Pool* pool,
+ const VkSwapchainCounterCreateInfoEXT* from,
+ VkSwapchainCounterCreateInfoEXT* to);
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void deepcopy_VkRefreshCycleDurationGOOGLE(
+ Pool* pool,
+ const VkRefreshCycleDurationGOOGLE* from,
+ VkRefreshCycleDurationGOOGLE* to);
+
+void deepcopy_VkPastPresentationTimingGOOGLE(
+ Pool* pool,
+ const VkPastPresentationTimingGOOGLE* from,
+ VkPastPresentationTimingGOOGLE* to);
+
+void deepcopy_VkPresentTimeGOOGLE(
+ Pool* pool,
+ const VkPresentTimeGOOGLE* from,
+ VkPresentTimeGOOGLE* to);
+
+void deepcopy_VkPresentTimesInfoGOOGLE(
+ Pool* pool,
+ const VkPresentTimesInfoGOOGLE* from,
+ VkPresentTimesInfoGOOGLE* to);
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ Pool* pool,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to);
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void deepcopy_VkViewportSwizzleNV(
+ Pool* pool,
+ const VkViewportSwizzleNV* from,
+ VkViewportSwizzleNV* to);
+
+void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
+ Pool* pool,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* from,
+ VkPipelineViewportSwizzleStateCreateInfoNV* to);
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT* to);
+
+void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
+ VkPipelineDiscardRectangleStateCreateInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to);
+
+void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void deepcopy_VkXYColorEXT(
+ Pool* pool,
+ const VkXYColorEXT* from,
+ VkXYColorEXT* to);
+
+void deepcopy_VkHdrMetadataEXT(
+ Pool* pool,
+ const VkHdrMetadataEXT* from,
+ VkHdrMetadataEXT* to);
+
+#endif
+#ifdef VK_MVK_ios_surface
+void deepcopy_VkIOSSurfaceCreateInfoMVK(
+ Pool* pool,
+ const VkIOSSurfaceCreateInfoMVK* from,
+ VkIOSSurfaceCreateInfoMVK* to);
+
+#endif
+#ifdef VK_MVK_macos_surface
+void deepcopy_VkMacOSSurfaceCreateInfoMVK(
+ Pool* pool,
+ const VkMacOSSurfaceCreateInfoMVK* from,
+ VkMacOSSurfaceCreateInfoMVK* to);
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void deepcopy_VkDebugUtilsObjectNameInfoEXT(
+ Pool* pool,
+ const VkDebugUtilsObjectNameInfoEXT* from,
+ VkDebugUtilsObjectNameInfoEXT* to);
+
+void deepcopy_VkDebugUtilsObjectTagInfoEXT(
+ Pool* pool,
+ const VkDebugUtilsObjectTagInfoEXT* from,
+ VkDebugUtilsObjectTagInfoEXT* to);
+
+void deepcopy_VkDebugUtilsLabelEXT(
+ Pool* pool,
+ const VkDebugUtilsLabelEXT* from,
+ VkDebugUtilsLabelEXT* to);
+
+void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
+ Pool* pool,
+ const VkDebugUtilsMessengerCallbackDataEXT* from,
+ VkDebugUtilsMessengerCallbackDataEXT* to);
+
+void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
+ Pool* pool,
+ const VkDebugUtilsMessengerCreateInfoEXT* from,
+ VkDebugUtilsMessengerCreateInfoEXT* to);
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void deepcopy_VkAndroidHardwareBufferUsageANDROID(
+ Pool* pool,
+ const VkAndroidHardwareBufferUsageANDROID* from,
+ VkAndroidHardwareBufferUsageANDROID* to);
+
+void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
+ Pool* pool,
+ const VkAndroidHardwareBufferPropertiesANDROID* from,
+ VkAndroidHardwareBufferPropertiesANDROID* to);
+
+void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ Pool* pool,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
+ VkAndroidHardwareBufferFormatPropertiesANDROID* to);
+
+void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
+ Pool* pool,
+ const VkImportAndroidHardwareBufferInfoANDROID* from,
+ VkImportAndroidHardwareBufferInfoANDROID* to);
+
+void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ Pool* pool,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* to);
+
+void deepcopy_VkExternalFormatANDROID(
+ Pool* pool,
+ const VkExternalFormatANDROID* from,
+ VkExternalFormatANDROID* to);
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void deepcopy_VkSamplerReductionModeCreateInfoEXT(
+ Pool* pool,
+ const VkSamplerReductionModeCreateInfoEXT* from,
+ VkSamplerReductionModeCreateInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* from,
+ VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* to);
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void deepcopy_VkSampleLocationEXT(
+ Pool* pool,
+ const VkSampleLocationEXT* from,
+ VkSampleLocationEXT* to);
+
+void deepcopy_VkSampleLocationsInfoEXT(
+ Pool* pool,
+ const VkSampleLocationsInfoEXT* from,
+ VkSampleLocationsInfoEXT* to);
+
+void deepcopy_VkAttachmentSampleLocationsEXT(
+ Pool* pool,
+ const VkAttachmentSampleLocationsEXT* from,
+ VkAttachmentSampleLocationsEXT* to);
+
+void deepcopy_VkSubpassSampleLocationsEXT(
+ Pool* pool,
+ const VkSubpassSampleLocationsEXT* from,
+ VkSubpassSampleLocationsEXT* to);
+
+void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
+ Pool* pool,
+ const VkRenderPassSampleLocationsBeginInfoEXT* from,
+ VkRenderPassSampleLocationsBeginInfoEXT* to);
+
+void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* from,
+ VkPipelineSampleLocationsStateCreateInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
+ VkPhysicalDeviceSampleLocationsPropertiesEXT* to);
+
+void deepcopy_VkMultisamplePropertiesEXT(
+ Pool* pool,
+ const VkMultisamplePropertiesEXT* from,
+ VkMultisamplePropertiesEXT* to);
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to);
+
+void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT* to);
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
+ Pool* pool,
+ const VkPipelineCoverageToColorStateCreateInfoNV* from,
+ VkPipelineCoverageToColorStateCreateInfoNV* to);
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
+ Pool* pool,
+ const VkPipelineCoverageModulationStateCreateInfoNV* from,
+ VkPipelineCoverageModulationStateCreateInfoNV* to);
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void deepcopy_VkValidationCacheCreateInfoEXT(
+ Pool* pool,
+ const VkValidationCacheCreateInfoEXT* from,
+ VkValidationCacheCreateInfoEXT* to);
+
+void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
+ Pool* pool,
+ const VkShaderModuleValidationCacheCreateInfoEXT* from,
+ VkShaderModuleValidationCacheCreateInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+ Pool* pool,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* from,
+ VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* from,
+ VkPhysicalDeviceDescriptorIndexingFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* from,
+ VkPhysicalDeviceDescriptorIndexingPropertiesEXT* to);
+
+void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+ Pool* pool,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* from,
+ VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* to);
+
+void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+ Pool* pool,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* from,
+ VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* to);
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ Pool* pool,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
+ VkDeviceQueueGlobalPriorityCreateInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void deepcopy_VkImportMemoryHostPointerInfoEXT(
+ Pool* pool,
+ const VkImportMemoryHostPointerInfoEXT* from,
+ VkImportMemoryHostPointerInfoEXT* to);
+
+void deepcopy_VkMemoryHostPointerPropertiesEXT(
+ Pool* pool,
+ const VkMemoryHostPointerPropertiesEXT* from,
+ VkMemoryHostPointerPropertiesEXT* to);
+
+void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to);
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
+ Pool* pool,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* from,
+ VkPhysicalDeviceShaderCorePropertiesAMD* to);
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ Pool* pool,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to);
+
+void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
+ Pool* pool,
+ const VkVertexInputBindingDivisorDescriptionEXT* from,
+ VkVertexInputBindingDivisorDescriptionEXT* to);
+
+void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ Pool* pool,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
+ VkPipelineVertexInputDivisorStateCreateInfoEXT* to);
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
+ Pool* pool,
+ const VkQueueFamilyCheckpointPropertiesNV* from,
+ VkQueueFamilyCheckpointPropertiesNV* to);
+
+void deepcopy_VkCheckpointDataNV(
+ Pool* pool,
+ const VkCheckpointDataNV* from,
+ VkCheckpointDataNV* to);
+
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
new file mode 100644
index 0000000..410ea7f
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -0,0 +1,826 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_extension_structs_guest
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "goldfish_vk_extension_structs_guest.h"
+
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+#endif
+#ifdef VK_VERSION_1_1
+#endif
+#ifdef VK_KHR_surface
+#endif
+#ifdef VK_KHR_swapchain
+#endif
+#ifdef VK_KHR_display
+#endif
+#ifdef VK_KHR_display_swapchain
+#endif
+#ifdef VK_KHR_xlib_surface
+#endif
+#ifdef VK_KHR_xcb_surface
+#endif
+#ifdef VK_KHR_wayland_surface
+#endif
+#ifdef VK_KHR_mir_surface
+#endif
+#ifdef VK_KHR_android_surface
+#endif
+#ifdef VK_KHR_win32_surface
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+#endif
+#ifdef VK_KHR_external_memory_fd
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+#endif
+#ifdef VK_KHR_push_descriptor
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+#endif
+#ifdef VK_KHR_shared_presentable_image
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+#endif
+#ifdef VK_KHR_external_fence_fd
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+#endif
+#ifdef VK_EXT_debug_report
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+#endif
+#ifdef VK_NVX_device_generated_commands
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+#endif
+#ifdef VK_EXT_display_control
+#endif
+#ifdef VK_GOOGLE_display_timing
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+#endif
+#ifdef VK_MVK_ios_surface
+#endif
+#ifdef VK_MVK_macos_surface
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+#endif
+uint32_t goldfish_vk_struct_type(
+ const void* structExtension)
+{
+ const uint32_t asStructType = *(reinterpret_cast<const uint32_t*>(structExtension));
+ return asStructType;
+}
+
+size_t goldfish_vk_extension_struct_size(
+ const void* structExtension)
+{
+ if (!structExtension)
+ {
+ return (size_t)0;
+ }
+ uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
+ switch(structType)
+ {
+#ifdef VK_VERSION_1_1
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+ {
+ return sizeof(VkPhysicalDeviceSubgroupProperties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+ {
+ return sizeof(VkPhysicalDevice16BitStorageFeatures);
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+ {
+ return sizeof(VkMemoryDedicatedRequirements);
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+ {
+ return sizeof(VkMemoryDedicatedAllocateInfo);
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+ {
+ return sizeof(VkMemoryAllocateFlagsInfo);
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+ {
+ return sizeof(VkDeviceGroupRenderPassBeginInfo);
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+ {
+ return sizeof(VkDeviceGroupCommandBufferBeginInfo);
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+ {
+ return sizeof(VkDeviceGroupSubmitInfo);
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+ {
+ return sizeof(VkDeviceGroupBindSparseInfo);
+ }
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+ {
+ return sizeof(VkBindBufferMemoryDeviceGroupInfo);
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+ {
+ return sizeof(VkBindImageMemoryDeviceGroupInfo);
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+ {
+ return sizeof(VkDeviceGroupDeviceCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+ {
+ return sizeof(VkPhysicalDeviceFeatures2);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+ {
+ return sizeof(VkPhysicalDevicePointClippingProperties);
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+ {
+ return sizeof(VkRenderPassInputAttachmentAspectCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+ {
+ return sizeof(VkImageViewUsageCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+ {
+ return sizeof(VkPipelineTessellationDomainOriginStateCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+ {
+ return sizeof(VkRenderPassMultiviewCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+ {
+ return sizeof(VkPhysicalDeviceMultiviewFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+ {
+ return sizeof(VkPhysicalDeviceMultiviewProperties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+ {
+ return sizeof(VkPhysicalDeviceVariablePointerFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+ {
+ return sizeof(VkPhysicalDeviceProtectedMemoryFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+ {
+ return sizeof(VkPhysicalDeviceProtectedMemoryProperties);
+ }
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+ {
+ return sizeof(VkProtectedSubmitInfo);
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+ {
+ return sizeof(VkSamplerYcbcrConversionInfo);
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+ {
+ return sizeof(VkBindImagePlaneMemoryInfo);
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+ {
+ return sizeof(VkImagePlaneMemoryRequirementsInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+ {
+ return sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures);
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+ {
+ return sizeof(VkSamplerYcbcrConversionImageFormatProperties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+ {
+ return sizeof(VkPhysicalDeviceExternalImageFormatInfo);
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+ {
+ return sizeof(VkExternalImageFormatProperties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+ {
+ return sizeof(VkPhysicalDeviceIDProperties);
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+ {
+ return sizeof(VkExternalMemoryImageCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+ {
+ return sizeof(VkExternalMemoryBufferCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+ {
+ return sizeof(VkExportMemoryAllocateInfo);
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+ {
+ return sizeof(VkExportFenceCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+ {
+ return sizeof(VkExportSemaphoreCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+ {
+ return sizeof(VkPhysicalDeviceMaintenance3Properties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+ {
+ return sizeof(VkPhysicalDeviceShaderDrawParameterFeatures);
+ }
+#endif
+#ifdef VK_KHR_swapchain
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+ {
+ return sizeof(VkImageSwapchainCreateInfoKHR);
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+ {
+ return sizeof(VkBindImageMemorySwapchainInfoKHR);
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+ {
+ return sizeof(VkDeviceGroupPresentInfoKHR);
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+ {
+ return sizeof(VkDeviceGroupSwapchainCreateInfoKHR);
+ }
+#endif
+#ifdef VK_KHR_display_swapchain
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+ {
+ return sizeof(VkDisplayPresentInfoKHR);
+ }
+#endif
+#ifdef VK_KHR_external_memory_win32
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ {
+ return sizeof(VkImportMemoryWin32HandleInfoKHR);
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ {
+ return sizeof(VkExportMemoryWin32HandleInfoKHR);
+ }
+#endif
+#ifdef VK_KHR_external_memory_fd
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+ {
+ return sizeof(VkImportMemoryFdInfoKHR);
+ }
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+ {
+ return sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR);
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+ {
+ return sizeof(VkExportSemaphoreWin32HandleInfoKHR);
+ }
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+ {
+ return sizeof(VkD3D12FenceSubmitInfoKHR);
+ }
+#endif
+#ifdef VK_KHR_push_descriptor
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+ {
+ return sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR);
+ }
+#endif
+#ifdef VK_KHR_incremental_present
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+ {
+ return sizeof(VkPresentRegionsKHR);
+ }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+ {
+ return sizeof(VkSharedPresentSurfaceCapabilitiesKHR);
+ }
+#endif
+#ifdef VK_KHR_external_fence_win32
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+ {
+ return sizeof(VkExportFenceWin32HandleInfoKHR);
+ }
+#endif
+#ifdef VK_KHR_image_format_list
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+ {
+ return sizeof(VkImageFormatListCreateInfoKHR);
+ }
+#endif
+#ifdef VK_KHR_8bit_storage
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+ {
+ return sizeof(VkPhysicalDevice8BitStorageFeaturesKHR);
+ }
+#endif
+#ifdef VK_ANDROID_native_buffer
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+ {
+ return sizeof(VkNativeBufferANDROID);
+ }
+#endif
+#ifdef VK_EXT_debug_report
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+ {
+ return sizeof(VkDebugReportCallbackCreateInfoEXT);
+ }
+#endif
+#ifdef VK_AMD_rasterization_order
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+ {
+ return sizeof(VkPipelineRasterizationStateRasterizationOrderAMD);
+ }
+#endif
+#ifdef VK_NV_dedicated_allocation
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+ {
+ return sizeof(VkDedicatedAllocationImageCreateInfoNV);
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+ {
+ return sizeof(VkDedicatedAllocationBufferCreateInfoNV);
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+ {
+ return sizeof(VkDedicatedAllocationMemoryAllocateInfoNV);
+ }
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+ {
+ return sizeof(VkTextureLODGatherFormatPropertiesAMD);
+ }
+#endif
+#ifdef VK_NV_external_memory
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+ {
+ return sizeof(VkExternalMemoryImageCreateInfoNV);
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+ {
+ return sizeof(VkExportMemoryAllocateInfoNV);
+ }
+#endif
+#ifdef VK_NV_external_memory_win32
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ {
+ return sizeof(VkImportMemoryWin32HandleInfoNV);
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ {
+ return sizeof(VkExportMemoryWin32HandleInfoNV);
+ }
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+ {
+ return sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV);
+ }
+#endif
+#ifdef VK_EXT_validation_flags
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+ {
+ return sizeof(VkValidationFlagsEXT);
+ }
+#endif
+#ifdef VK_EXT_conditional_rendering
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT);
+ }
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+ {
+ return sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT);
+ }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+ {
+ return sizeof(VkPipelineViewportWScalingStateCreateInfoNV);
+ }
+#endif
+#ifdef VK_EXT_display_control
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+ {
+ return sizeof(VkSwapchainCounterCreateInfoEXT);
+ }
+#endif
+#ifdef VK_GOOGLE_display_timing
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+ {
+ return sizeof(VkPresentTimesInfoGOOGLE);
+ }
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+ {
+ return sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX);
+ }
+#endif
+#ifdef VK_NV_viewport_swizzle
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+ {
+ return sizeof(VkPipelineViewportSwizzleStateCreateInfoNV);
+ }
+#endif
+#ifdef VK_EXT_discard_rectangles
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+ {
+ return sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT);
+ }
+#endif
+#ifdef VK_EXT_conservative_rasterization
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+ {
+ return sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT);
+ }
+#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+ {
+ return sizeof(VkDebugUtilsMessengerCreateInfoEXT);
+ }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+ {
+ return sizeof(VkAndroidHardwareBufferUsageANDROID);
+ }
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+ {
+ return sizeof(VkAndroidHardwareBufferFormatPropertiesANDROID);
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+ {
+ return sizeof(VkImportAndroidHardwareBufferInfoANDROID);
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+ {
+ return sizeof(VkExternalFormatANDROID);
+ }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+ {
+ return sizeof(VkSamplerReductionModeCreateInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT);
+ }
+#endif
+#ifdef VK_EXT_sample_locations
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+ {
+ return sizeof(VkSampleLocationsInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+ {
+ return sizeof(VkRenderPassSampleLocationsBeginInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+ {
+ return sizeof(VkPipelineSampleLocationsStateCreateInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT);
+ }
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+ {
+ return sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT);
+ }
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+ {
+ return sizeof(VkPipelineCoverageToColorStateCreateInfoNV);
+ }
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+ {
+ return sizeof(VkPipelineCoverageModulationStateCreateInfoNV);
+ }
+#endif
+#ifdef VK_EXT_validation_cache
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+ {
+ return sizeof(VkShaderModuleValidationCacheCreateInfoEXT);
+ }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+ {
+ return sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceDescriptorIndexingPropertiesEXT);
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+ {
+ return sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+ {
+ return sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupportEXT);
+ }
+#endif
+#ifdef VK_EXT_global_priority
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+ {
+ return sizeof(VkDeviceQueueGlobalPriorityCreateInfoEXT);
+ }
+#endif
+#ifdef VK_EXT_external_memory_host
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+ {
+ return sizeof(VkImportMemoryHostPointerInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT);
+ }
+#endif
+#ifdef VK_AMD_shader_core_properties
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+ {
+ return sizeof(VkPhysicalDeviceShaderCorePropertiesAMD);
+ }
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+ {
+ return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+ {
+ return sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT);
+ }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+ {
+ return sizeof(VkQueueFamilyCheckpointPropertiesNV);
+ }
+#endif
+ default:
+ {
+ return (size_t)0;
+ }
+ }
+}
+
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
new file mode 100644
index 0000000..6c5a04c
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -0,0 +1,295 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_extension_structs_guest
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "vk_platform_compat.h"
+#include "goldfish_vk_private_defs.h"
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+uint32_t goldfish_vk_struct_type(
+ const void* structExtension);
+
+size_t goldfish_vk_extension_struct_size(
+ const void* structExtension);
+
+#ifdef VK_VERSION_1_0
+#endif
+#ifdef VK_VERSION_1_1
+#endif
+#ifdef VK_KHR_surface
+#endif
+#ifdef VK_KHR_swapchain
+#endif
+#ifdef VK_KHR_display
+#endif
+#ifdef VK_KHR_display_swapchain
+#endif
+#ifdef VK_KHR_xlib_surface
+#endif
+#ifdef VK_KHR_xcb_surface
+#endif
+#ifdef VK_KHR_wayland_surface
+#endif
+#ifdef VK_KHR_mir_surface
+#endif
+#ifdef VK_KHR_android_surface
+#endif
+#ifdef VK_KHR_win32_surface
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+#endif
+#ifdef VK_KHR_external_memory_fd
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+#endif
+#ifdef VK_KHR_push_descriptor
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+#endif
+#ifdef VK_KHR_shared_presentable_image
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+#endif
+#ifdef VK_KHR_external_fence_fd
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+#endif
+#ifdef VK_EXT_debug_report
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+#endif
+#ifdef VK_NVX_device_generated_commands
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+#endif
+#ifdef VK_EXT_display_control
+#endif
+#ifdef VK_GOOGLE_display_timing
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+#endif
+#ifdef VK_MVK_ios_surface
+#endif
+#ifdef VK_MVK_macos_surface
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
new file mode 100644
index 0000000..e6ab090
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
@@ -0,0 +1,5371 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_handlemap_guest
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "goldfish_vk_handlemap_guest.h"
+
+
+#include "goldfish_vk_extension_structs_guest.h"
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+void handlemap_extension_struct(
+ VulkanHandleMapping* handlemap,
+ void* structExtension_out);
+
+#ifdef VK_VERSION_1_0
+void handlemap_VkApplicationInfo(
+ VulkanHandleMapping* handlemap,
+ VkApplicationInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkInstanceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkInstanceCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pApplicationInfo)
+ {
+ handlemap_VkApplicationInfo(handlemap, (VkApplicationInfo*)(toMap->pApplicationInfo));
+ }
+}
+
+void handlemap_VkAllocationCallbacks(
+ VulkanHandleMapping* handlemap,
+ VkAllocationCallbacks* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceFeatures* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkFormatProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkExtent3D(
+ VulkanHandleMapping* handlemap,
+ VkExtent3D* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkImageFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkImageFormatProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->maxExtent));
+}
+
+void handlemap_VkPhysicalDeviceLimits(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceLimits* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceSparseProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSparseProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkPhysicalDeviceLimits(handlemap, (VkPhysicalDeviceLimits*)(&toMap->limits));
+ handlemap_VkPhysicalDeviceSparseProperties(handlemap, (VkPhysicalDeviceSparseProperties*)(&toMap->sparseProperties));
+}
+
+void handlemap_VkQueueFamilyProperties(
+ VulkanHandleMapping* handlemap,
+ VkQueueFamilyProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->minImageTransferGranularity));
+}
+
+void handlemap_VkMemoryType(
+ VulkanHandleMapping* handlemap,
+ VkMemoryType* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkMemoryHeap(
+ VulkanHandleMapping* handlemap,
+ VkMemoryHeap* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceMemoryProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMemoryProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
+ {
+ handlemap_VkMemoryType(handlemap, (VkMemoryType*)(toMap->memoryTypes + i));
+ }
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
+ {
+ handlemap_VkMemoryHeap(handlemap, (VkMemoryHeap*)(toMap->memoryHeaps + i));
+ }
+}
+
+void handlemap_VkDeviceQueueCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceQueueCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pQueueCreateInfos)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->queueCreateInfoCount; ++i)
+ {
+ handlemap_VkDeviceQueueCreateInfo(handlemap, (VkDeviceQueueCreateInfo*)(toMap->pQueueCreateInfos + i));
+ }
+ }
+ if (toMap->pEnabledFeatures)
+ {
+ handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(toMap->pEnabledFeatures));
+ }
+}
+
+void handlemap_VkExtensionProperties(
+ VulkanHandleMapping* handlemap,
+ VkExtensionProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkLayerProperties(
+ VulkanHandleMapping* handlemap,
+ VkLayerProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkSubmitInfo(
+ VulkanHandleMapping* handlemap,
+ VkSubmitInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pWaitSemaphores)
+ {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+ }
+ if (toMap->pCommandBuffers)
+ {
+ handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)toMap->pCommandBuffers, toMap->commandBufferCount);
+ }
+ if (toMap->pSignalSemaphores)
+ {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
+ }
+}
+
+void handlemap_VkMemoryAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkMemoryAllocateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMappedMemoryRange(
+ VulkanHandleMapping* handlemap,
+ VkMappedMemoryRange* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkMemoryRequirements(
+ VulkanHandleMapping* handlemap,
+ VkMemoryRequirements* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkSparseImageFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageFormatProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageGranularity));
+}
+
+void handlemap_VkSparseImageMemoryRequirements(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryRequirements* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->formatProperties));
+}
+
+void handlemap_VkSparseMemoryBind(
+ VulkanHandleMapping* handlemap,
+ VkSparseMemoryBind* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkSparseBufferMemoryBindInfo(
+ VulkanHandleMapping* handlemap,
+ VkSparseBufferMemoryBindInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+ if (toMap->pBinds)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
+ {
+ handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
+ }
+ }
+}
+
+void handlemap_VkSparseImageOpaqueMemoryBindInfo(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageOpaqueMemoryBindInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+ if (toMap->pBinds)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
+ {
+ handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
+ }
+ }
+}
+
+void handlemap_VkImageSubresource(
+ VulkanHandleMapping* handlemap,
+ VkImageSubresource* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkOffset3D(
+ VulkanHandleMapping* handlemap,
+ VkOffset3D* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkSparseImageMemoryBind(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryBind* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkImageSubresource(handlemap, (VkImageSubresource*)(&toMap->subresource));
+ handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->offset));
+ handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkSparseImageMemoryBindInfo(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryBindInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+ if (toMap->pBinds)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
+ {
+ handlemap_VkSparseImageMemoryBind(handlemap, (VkSparseImageMemoryBind*)(toMap->pBinds + i));
+ }
+ }
+}
+
+void handlemap_VkBindSparseInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindSparseInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pWaitSemaphores)
+ {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+ }
+ if (toMap->pBufferBinds)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bufferBindCount; ++i)
+ {
+ handlemap_VkSparseBufferMemoryBindInfo(handlemap, (VkSparseBufferMemoryBindInfo*)(toMap->pBufferBinds + i));
+ }
+ }
+ if (toMap->pImageOpaqueBinds)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->imageOpaqueBindCount; ++i)
+ {
+ handlemap_VkSparseImageOpaqueMemoryBindInfo(handlemap, (VkSparseImageOpaqueMemoryBindInfo*)(toMap->pImageOpaqueBinds + i));
+ }
+ }
+ if (toMap->pImageBinds)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->imageBindCount; ++i)
+ {
+ handlemap_VkSparseImageMemoryBindInfo(handlemap, (VkSparseImageMemoryBindInfo*)(toMap->pImageBinds + i));
+ }
+ }
+ if (toMap->pSignalSemaphores)
+ {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
+ }
+}
+
+void handlemap_VkFenceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkFenceCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkSemaphoreCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkSemaphoreCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkEventCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkEventCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkQueryPoolCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkQueryPoolCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkBufferCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkBufferCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkBufferViewCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkBufferViewCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkImageCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkImageCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+}
+
+void handlemap_VkSubresourceLayout(
+ VulkanHandleMapping* handlemap,
+ VkSubresourceLayout* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkComponentMapping(
+ VulkanHandleMapping* handlemap,
+ VkComponentMapping* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkImageSubresourceRange(
+ VulkanHandleMapping* handlemap,
+ VkImageSubresourceRange* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkImageViewCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkImageViewCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+ handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
+ handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
+}
+
+void handlemap_VkShaderModuleCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkShaderModuleCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPipelineCacheCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineCacheCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkSpecializationMapEntry(
+ VulkanHandleMapping* handlemap,
+ VkSpecializationMapEntry* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkSpecializationInfo(
+ VulkanHandleMapping* handlemap,
+ VkSpecializationInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pMapEntries)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->mapEntryCount; ++i)
+ {
+ handlemap_VkSpecializationMapEntry(handlemap, (VkSpecializationMapEntry*)(toMap->pMapEntries + i));
+ }
+ }
+}
+
+void handlemap_VkPipelineShaderStageCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineShaderStageCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkShaderModule((VkShaderModule*)&toMap->module);
+ if (toMap->pSpecializationInfo)
+ {
+ handlemap_VkSpecializationInfo(handlemap, (VkSpecializationInfo*)(toMap->pSpecializationInfo));
+ }
+}
+
+void handlemap_VkVertexInputBindingDescription(
+ VulkanHandleMapping* handlemap,
+ VkVertexInputBindingDescription* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkVertexInputAttributeDescription(
+ VulkanHandleMapping* handlemap,
+ VkVertexInputAttributeDescription* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPipelineVertexInputStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineVertexInputStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pVertexBindingDescriptions)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDescriptionCount; ++i)
+ {
+ handlemap_VkVertexInputBindingDescription(handlemap, (VkVertexInputBindingDescription*)(toMap->pVertexBindingDescriptions + i));
+ }
+ }
+ if (toMap->pVertexAttributeDescriptions)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->vertexAttributeDescriptionCount; ++i)
+ {
+ handlemap_VkVertexInputAttributeDescription(handlemap, (VkVertexInputAttributeDescription*)(toMap->pVertexAttributeDescriptions + i));
+ }
+ }
+}
+
+void handlemap_VkPipelineInputAssemblyStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineInputAssemblyStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPipelineTessellationStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineTessellationStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkViewport(
+ VulkanHandleMapping* handlemap,
+ VkViewport* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkOffset2D(
+ VulkanHandleMapping* handlemap,
+ VkOffset2D* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkExtent2D(
+ VulkanHandleMapping* handlemap,
+ VkExtent2D* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkRect2D(
+ VulkanHandleMapping* handlemap,
+ VkRect2D* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
+}
+
+void handlemap_VkPipelineViewportStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineViewportStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pViewports)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
+ {
+ handlemap_VkViewport(handlemap, (VkViewport*)(toMap->pViewports + i));
+ }
+ }
+ if (toMap->pScissors)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->scissorCount; ++i)
+ {
+ handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pScissors + i));
+ }
+ }
+}
+
+void handlemap_VkPipelineRasterizationStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineRasterizationStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPipelineMultisampleStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineMultisampleStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkStencilOpState(
+ VulkanHandleMapping* handlemap,
+ VkStencilOpState* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPipelineDepthStencilStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineDepthStencilStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->front));
+ handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->back));
+}
+
+void handlemap_VkPipelineColorBlendAttachmentState(
+ VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendAttachmentState* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPipelineColorBlendStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
+ {
+ handlemap_VkPipelineColorBlendAttachmentState(handlemap, (VkPipelineColorBlendAttachmentState*)(toMap->pAttachments + i));
+ }
+ }
+}
+
+void handlemap_VkPipelineDynamicStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineDynamicStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkGraphicsPipelineCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkGraphicsPipelineCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pStages)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i)
+ {
+ handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
+ }
+ }
+ if (toMap->pVertexInputState)
+ {
+ handlemap_VkPipelineVertexInputStateCreateInfo(handlemap, (VkPipelineVertexInputStateCreateInfo*)(toMap->pVertexInputState));
+ }
+ if (toMap->pInputAssemblyState)
+ {
+ handlemap_VkPipelineInputAssemblyStateCreateInfo(handlemap, (VkPipelineInputAssemblyStateCreateInfo*)(toMap->pInputAssemblyState));
+ }
+ if (toMap->pTessellationState)
+ {
+ handlemap_VkPipelineTessellationStateCreateInfo(handlemap, (VkPipelineTessellationStateCreateInfo*)(toMap->pTessellationState));
+ }
+ if (toMap->pViewportState)
+ {
+ handlemap_VkPipelineViewportStateCreateInfo(handlemap, (VkPipelineViewportStateCreateInfo*)(toMap->pViewportState));
+ }
+ if (toMap->pRasterizationState)
+ {
+ handlemap_VkPipelineRasterizationStateCreateInfo(handlemap, (VkPipelineRasterizationStateCreateInfo*)(toMap->pRasterizationState));
+ }
+ if (toMap->pMultisampleState)
+ {
+ handlemap_VkPipelineMultisampleStateCreateInfo(handlemap, (VkPipelineMultisampleStateCreateInfo*)(toMap->pMultisampleState));
+ }
+ if (toMap->pDepthStencilState)
+ {
+ handlemap_VkPipelineDepthStencilStateCreateInfo(handlemap, (VkPipelineDepthStencilStateCreateInfo*)(toMap->pDepthStencilState));
+ }
+ if (toMap->pColorBlendState)
+ {
+ handlemap_VkPipelineColorBlendStateCreateInfo(handlemap, (VkPipelineColorBlendStateCreateInfo*)(toMap->pColorBlendState));
+ }
+ if (toMap->pDynamicState)
+ {
+ handlemap_VkPipelineDynamicStateCreateInfo(handlemap, (VkPipelineDynamicStateCreateInfo*)(toMap->pDynamicState));
+ }
+ handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
+ handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
+ handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
+}
+
+void handlemap_VkComputePipelineCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkComputePipelineCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(&toMap->stage));
+ handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
+ handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
+}
+
+void handlemap_VkPushConstantRange(
+ VulkanHandleMapping* handlemap,
+ VkPushConstantRange* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPipelineLayoutCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineLayoutCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pSetLayouts)
+ {
+ handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->setLayoutCount);
+ }
+ if (toMap->pPushConstantRanges)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->pushConstantRangeCount; ++i)
+ {
+ handlemap_VkPushConstantRange(handlemap, (VkPushConstantRange*)(toMap->pPushConstantRanges + i));
+ }
+ }
+}
+
+void handlemap_VkSamplerCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkSamplerCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDescriptorSetLayoutBinding(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutBinding* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pImmutableSamplers)
+ {
+ handlemap->mapHandles_VkSampler((VkSampler*)toMap->pImmutableSamplers, toMap->descriptorCount);
+ }
+}
+
+void handlemap_VkDescriptorSetLayoutCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pBindings)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bindingCount; ++i)
+ {
+ handlemap_VkDescriptorSetLayoutBinding(handlemap, (VkDescriptorSetLayoutBinding*)(toMap->pBindings + i));
+ }
+ }
+}
+
+void handlemap_VkDescriptorPoolSize(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorPoolSize* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkDescriptorPoolCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorPoolCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pPoolSizes)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->poolSizeCount; ++i)
+ {
+ handlemap_VkDescriptorPoolSize(handlemap, (VkDescriptorPoolSize*)(toMap->pPoolSizes + i));
+ }
+ }
+}
+
+void handlemap_VkDescriptorSetAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetAllocateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDescriptorPool((VkDescriptorPool*)&toMap->descriptorPool);
+ if (toMap->pSetLayouts)
+ {
+ handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->descriptorSetCount);
+ }
+}
+
+void handlemap_VkDescriptorImageInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorImageInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkSampler((VkSampler*)&toMap->sampler);
+ handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
+}
+
+void handlemap_VkDescriptorBufferInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorBufferInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkWriteDescriptorSet(
+ VulkanHandleMapping* handlemap,
+ VkWriteDescriptorSet* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
+ if (toMap->pImageInfo)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
+ {
+ handlemap_VkDescriptorImageInfo(handlemap, (VkDescriptorImageInfo*)(toMap->pImageInfo + i));
+ }
+ }
+ if (toMap->pBufferInfo)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
+ {
+ handlemap_VkDescriptorBufferInfo(handlemap, (VkDescriptorBufferInfo*)(toMap->pBufferInfo + i));
+ }
+ }
+ if (toMap->pTexelBufferView)
+ {
+ handlemap->mapHandles_VkBufferView((VkBufferView*)toMap->pTexelBufferView, toMap->descriptorCount);
+ }
+}
+
+void handlemap_VkCopyDescriptorSet(
+ VulkanHandleMapping* handlemap,
+ VkCopyDescriptorSet* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->srcSet);
+ handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
+}
+
+void handlemap_VkFramebufferCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkFramebufferCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
+ if (toMap->pAttachments)
+ {
+ handlemap->mapHandles_VkImageView((VkImageView*)toMap->pAttachments, toMap->attachmentCount);
+ }
+}
+
+void handlemap_VkAttachmentDescription(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentDescription* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkAttachmentReference(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentReference* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkSubpassDescription(
+ VulkanHandleMapping* handlemap,
+ VkSubpassDescription* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pInputAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
+ {
+ handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pInputAttachments + i));
+ }
+ }
+ if (toMap->pColorAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
+ {
+ handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pColorAttachments + i));
+ }
+ }
+ if (toMap->pResolveAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
+ {
+ handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pResolveAttachments + i));
+ }
+ }
+ if (toMap->pDepthStencilAttachment)
+ {
+ handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pDepthStencilAttachment));
+ }
+}
+
+void handlemap_VkSubpassDependency(
+ VulkanHandleMapping* handlemap,
+ VkSubpassDependency* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkRenderPassCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
+ {
+ handlemap_VkAttachmentDescription(handlemap, (VkAttachmentDescription*)(toMap->pAttachments + i));
+ }
+ }
+ if (toMap->pSubpasses)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
+ {
+ handlemap_VkSubpassDescription(handlemap, (VkSubpassDescription*)(toMap->pSubpasses + i));
+ }
+ }
+ if (toMap->pDependencies)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
+ {
+ handlemap_VkSubpassDependency(handlemap, (VkSubpassDependency*)(toMap->pDependencies + i));
+ }
+ }
+}
+
+void handlemap_VkCommandPoolCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkCommandPoolCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkCommandBufferAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkCommandBufferAllocateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkCommandPool((VkCommandPool*)&toMap->commandPool);
+}
+
+void handlemap_VkCommandBufferInheritanceInfo(
+ VulkanHandleMapping* handlemap,
+ VkCommandBufferInheritanceInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
+ handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
+}
+
+void handlemap_VkCommandBufferBeginInfo(
+ VulkanHandleMapping* handlemap,
+ VkCommandBufferBeginInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pInheritanceInfo)
+ {
+ handlemap_VkCommandBufferInheritanceInfo(handlemap, (VkCommandBufferInheritanceInfo*)(toMap->pInheritanceInfo));
+ }
+}
+
+void handlemap_VkBufferCopy(
+ VulkanHandleMapping* handlemap,
+ VkBufferCopy* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkImageSubresourceLayers(
+ VulkanHandleMapping* handlemap,
+ VkImageSubresourceLayers* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkImageCopy(
+ VulkanHandleMapping* handlemap,
+ VkImageCopy* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
+ handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
+ handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+}
+
+void handlemap_VkImageBlit(
+ VulkanHandleMapping* handlemap,
+ VkImageBlit* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ {
+ handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->srcOffsets + i));
+ }
+ handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ {
+ handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->dstOffsets + i));
+ }
+}
+
+void handlemap_VkBufferImageCopy(
+ VulkanHandleMapping* handlemap,
+ VkBufferImageCopy* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->imageSubresource));
+ handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
+ handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
+}
+
+void handlemap_VkClearColorValue(
+ VulkanHandleMapping* handlemap,
+ VkClearColorValue* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkClearDepthStencilValue(
+ VulkanHandleMapping* handlemap,
+ VkClearDepthStencilValue* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkClearValue(
+ VulkanHandleMapping* handlemap,
+ VkClearValue* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkClearColorValue(handlemap, (VkClearColorValue*)(&toMap->color));
+ handlemap_VkClearDepthStencilValue(handlemap, (VkClearDepthStencilValue*)(&toMap->depthStencil));
+}
+
+void handlemap_VkClearAttachment(
+ VulkanHandleMapping* handlemap,
+ VkClearAttachment* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkClearValue(handlemap, (VkClearValue*)(&toMap->clearValue));
+}
+
+void handlemap_VkClearRect(
+ VulkanHandleMapping* handlemap,
+ VkClearRect* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->rect));
+}
+
+void handlemap_VkImageResolve(
+ VulkanHandleMapping* handlemap,
+ VkImageResolve* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
+ handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
+ handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+}
+
+void handlemap_VkMemoryBarrier(
+ VulkanHandleMapping* handlemap,
+ VkMemoryBarrier* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkBufferMemoryBarrier(
+ VulkanHandleMapping* handlemap,
+ VkBufferMemoryBarrier* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkImageMemoryBarrier(
+ VulkanHandleMapping* handlemap,
+ VkImageMemoryBarrier* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+ handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
+}
+
+void handlemap_VkRenderPassBeginInfo(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassBeginInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
+ handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
+ handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
+ if (toMap->pClearValues)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->clearValueCount; ++i)
+ {
+ handlemap_VkClearValue(handlemap, (VkClearValue*)(toMap->pClearValues + i));
+ }
+ }
+}
+
+void handlemap_VkDispatchIndirectCommand(
+ VulkanHandleMapping* handlemap,
+ VkDispatchIndirectCommand* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkDrawIndexedIndirectCommand(
+ VulkanHandleMapping* handlemap,
+ VkDrawIndexedIndirectCommand* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkDrawIndirectCommand(
+ VulkanHandleMapping* handlemap,
+ VkDrawIndirectCommand* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkBaseOutStructure(
+ VulkanHandleMapping* handlemap,
+ VkBaseOutStructure* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkBaseInStructure(
+ VulkanHandleMapping* handlemap,
+ VkBaseInStructure* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_VERSION_1_1
+void handlemap_VkPhysicalDeviceSubgroupProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSubgroupProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkBindBufferMemoryInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindBufferMemoryInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkBindImageMemoryInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindImageMemoryInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkPhysicalDevice16BitStorageFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDevice16BitStorageFeatures* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMemoryDedicatedRequirements(
+ VulkanHandleMapping* handlemap,
+ VkMemoryDedicatedRequirements* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMemoryDedicatedAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkMemoryDedicatedAllocateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkMemoryAllocateFlagsInfo(
+ VulkanHandleMapping* handlemap,
+ VkMemoryAllocateFlagsInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceGroupRenderPassBeginInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupRenderPassBeginInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pDeviceRenderAreas)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->deviceRenderAreaCount; ++i)
+ {
+ handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDeviceRenderAreas + i));
+ }
+ }
+}
+
+void handlemap_VkDeviceGroupCommandBufferBeginInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupCommandBufferBeginInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceGroupSubmitInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupSubmitInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceGroupBindSparseInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupBindSparseInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkBindBufferMemoryDeviceGroupInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindBufferMemoryDeviceGroupInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkBindImageMemoryDeviceGroupInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindImageMemoryDeviceGroupInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pSplitInstanceBindRegions)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->splitInstanceBindRegionCount; ++i)
+ {
+ handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pSplitInstanceBindRegions + i));
+ }
+ }
+}
+
+void handlemap_VkPhysicalDeviceGroupProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceGroupProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
+}
+
+void handlemap_VkDeviceGroupDeviceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupDeviceCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pPhysicalDevices)
+ {
+ handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->pPhysicalDevices, toMap->physicalDeviceCount);
+ }
+}
+
+void handlemap_VkBufferMemoryRequirementsInfo2(
+ VulkanHandleMapping* handlemap,
+ VkBufferMemoryRequirementsInfo2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkImageMemoryRequirementsInfo2(
+ VulkanHandleMapping* handlemap,
+ VkImageMemoryRequirementsInfo2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+}
+
+void handlemap_VkImageSparseMemoryRequirementsInfo2(
+ VulkanHandleMapping* handlemap,
+ VkImageSparseMemoryRequirementsInfo2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+}
+
+void handlemap_VkMemoryRequirements2(
+ VulkanHandleMapping* handlemap,
+ VkMemoryRequirements2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkMemoryRequirements(handlemap, (VkMemoryRequirements*)(&toMap->memoryRequirements));
+}
+
+void handlemap_VkSparseImageMemoryRequirements2(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryRequirements2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkSparseImageMemoryRequirements(handlemap, (VkSparseImageMemoryRequirements*)(&toMap->memoryRequirements));
+}
+
+void handlemap_VkPhysicalDeviceFeatures2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceFeatures2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(&toMap->features));
+}
+
+void handlemap_VkPhysicalDeviceProperties2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProperties2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkPhysicalDeviceProperties(handlemap, (VkPhysicalDeviceProperties*)(&toMap->properties));
+}
+
+void handlemap_VkFormatProperties2(
+ VulkanHandleMapping* handlemap,
+ VkFormatProperties2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkFormatProperties(handlemap, (VkFormatProperties*)(&toMap->formatProperties));
+}
+
+void handlemap_VkImageFormatProperties2(
+ VulkanHandleMapping* handlemap,
+ VkImageFormatProperties2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
+}
+
+void handlemap_VkPhysicalDeviceImageFormatInfo2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceImageFormatInfo2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkQueueFamilyProperties2(
+ VulkanHandleMapping* handlemap,
+ VkQueueFamilyProperties2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkQueueFamilyProperties(handlemap, (VkQueueFamilyProperties*)(&toMap->queueFamilyProperties));
+}
+
+void handlemap_VkPhysicalDeviceMemoryProperties2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMemoryProperties2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkPhysicalDeviceMemoryProperties(handlemap, (VkPhysicalDeviceMemoryProperties*)(&toMap->memoryProperties));
+}
+
+void handlemap_VkSparseImageFormatProperties2(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageFormatProperties2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->properties));
+}
+
+void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSparseImageFormatInfo2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDevicePointClippingProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDevicePointClippingProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkInputAttachmentAspectReference(
+ VulkanHandleMapping* handlemap,
+ VkInputAttachmentAspectReference* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassInputAttachmentAspectCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pAspectReferences)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->aspectReferenceCount; ++i)
+ {
+ handlemap_VkInputAttachmentAspectReference(handlemap, (VkInputAttachmentAspectReference*)(toMap->pAspectReferences + i));
+ }
+ }
+}
+
+void handlemap_VkImageViewUsageCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkImageViewUsageCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineTessellationDomainOriginStateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkRenderPassMultiviewCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassMultiviewCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceMultiviewFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewFeatures* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceMultiviewProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceVariablePointerFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVariablePointerFeatures* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProtectedMemoryFeatures* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProtectedMemoryProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceQueueInfo2(
+ VulkanHandleMapping* handlemap,
+ VkDeviceQueueInfo2* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkProtectedSubmitInfo(
+ VulkanHandleMapping* handlemap,
+ VkProtectedSubmitInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkSamplerYcbcrConversionCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
+}
+
+void handlemap_VkSamplerYcbcrConversionInfo(
+ VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&toMap->conversion);
+}
+
+void handlemap_VkBindImagePlaneMemoryInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindImagePlaneMemoryInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkImagePlaneMemoryRequirementsInfo(
+ VulkanHandleMapping* handlemap,
+ VkImagePlaneMemoryRequirementsInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionImageFormatProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDescriptorUpdateTemplateEntry(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorUpdateTemplateEntry* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkDescriptorUpdateTemplateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorUpdateTemplateCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pDescriptorUpdateEntries)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->descriptorUpdateEntryCount; ++i)
+ {
+ handlemap_VkDescriptorUpdateTemplateEntry(handlemap, (VkDescriptorUpdateTemplateEntry*)(toMap->pDescriptorUpdateEntries + i));
+ }
+ }
+ handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&toMap->descriptorSetLayout);
+ handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
+}
+
+void handlemap_VkExternalMemoryProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalMemoryProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalImageFormatInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExternalImageFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalImageFormatProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
+}
+
+void handlemap_VkPhysicalDeviceExternalBufferInfo(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalBufferInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExternalBufferProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalBufferProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
+}
+
+void handlemap_VkPhysicalDeviceIDProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceIDProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExternalMemoryImageCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExternalMemoryImageCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExternalMemoryBufferCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExternalMemoryBufferCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExportMemoryAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExportMemoryAllocateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceExternalFenceInfo(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalFenceInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExternalFenceProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalFenceProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExportFenceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExportFenceCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExportSemaphoreCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExportSemaphoreCreateInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalSemaphoreInfo* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExternalSemaphoreProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalSemaphoreProperties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceMaintenance3Properties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMaintenance3Properties* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDescriptorSetLayoutSupport(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutSupport* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceShaderDrawParameterFeatures* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_surface
+void handlemap_VkSurfaceCapabilitiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilitiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minImageExtent));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxImageExtent));
+}
+
+void handlemap_VkSurfaceFormatKHR(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceFormatKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+#endif
+#ifdef VK_KHR_swapchain
+void handlemap_VkSwapchainCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSwapchainCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->imageExtent));
+ handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->oldSwapchain);
+}
+
+void handlemap_VkPresentInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkPresentInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pWaitSemaphores)
+ {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+ }
+ if (toMap->pSwapchains)
+ {
+ handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)toMap->pSwapchains, toMap->swapchainCount);
+ }
+}
+
+void handlemap_VkImageSwapchainCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImageSwapchainCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
+}
+
+void handlemap_VkBindImageMemorySwapchainInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkBindImageMemorySwapchainInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
+}
+
+void handlemap_VkAcquireNextImageInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkAcquireNextImageInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+ handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+void handlemap_VkDeviceGroupPresentCapabilitiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupPresentCapabilitiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceGroupPresentInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupPresentInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupSwapchainCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_display
+void handlemap_VkDisplayPropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPropertiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->display);
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalDimensions));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalResolution));
+}
+
+void handlemap_VkDisplayModeParametersKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayModeParametersKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->visibleRegion));
+}
+
+void handlemap_VkDisplayModePropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayModePropertiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
+ handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
+}
+
+void handlemap_VkDisplayModeCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayModeCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
+}
+
+void handlemap_VkDisplayPlaneCapabilitiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlaneCapabilitiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minSrcPosition));
+ handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->maxSrcPosition));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minSrcExtent));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSrcExtent));
+ handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minDstPosition));
+ handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->maxDstPosition));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minDstExtent));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxDstExtent));
+}
+
+void handlemap_VkDisplayPlanePropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlanePropertiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->currentDisplay);
+}
+
+void handlemap_VkDisplaySurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplaySurfaceCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->imageExtent));
+}
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void handlemap_VkDisplayPresentInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPresentInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->srcRect));
+ handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->dstRect));
+}
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void handlemap_VkXlibSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkXlibSurfaceCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void handlemap_VkXcbSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkXcbSurfaceCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void handlemap_VkWaylandSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkWaylandSurfaceCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_mir_surface
+void handlemap_VkMirSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkMirSurfaceCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_android_surface
+void handlemap_VkAndroidSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkAndroidSurfaceCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_win32_surface
+void handlemap_VkWin32SurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkWin32SurfaceCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void handlemap_VkImportMemoryWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportMemoryWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExportMemoryWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkExportMemoryWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMemoryWin32HandlePropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkMemoryWin32HandlePropertiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMemoryGetWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkMemoryGetWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void handlemap_VkImportMemoryFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportMemoryFdInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMemoryFdPropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkMemoryFdPropertiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMemoryGetFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkMemoryGetFdInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pAcquireSyncs)
+ {
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
+ }
+ if (toMap->pReleaseSyncs)
+ {
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
+ }
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void handlemap_VkImportSemaphoreWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportSemaphoreWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+void handlemap_VkExportSemaphoreWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkExportSemaphoreWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkD3D12FenceSubmitInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkD3D12FenceSubmitInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkSemaphoreGetWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSemaphoreGetWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void handlemap_VkImportSemaphoreFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportSemaphoreFdInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+void handlemap_VkSemaphoreGetFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSemaphoreGetFdInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDevicePushDescriptorPropertiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void handlemap_VkRectLayerKHR(
+ VulkanHandleMapping* handlemap,
+ VkRectLayerKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
+}
+
+void handlemap_VkPresentRegionKHR(
+ VulkanHandleMapping* handlemap,
+ VkPresentRegionKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pRectangles)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->rectangleCount; ++i)
+ {
+ handlemap_VkRectLayerKHR(handlemap, (VkRectLayerKHR*)(toMap->pRectangles + i));
+ }
+ }
+}
+
+void handlemap_VkPresentRegionsKHR(
+ VulkanHandleMapping* handlemap,
+ VkPresentRegionsKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pRegions)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i)
+ {
+ handlemap_VkPresentRegionKHR(handlemap, (VkPresentRegionKHR*)(toMap->pRegions + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void handlemap_VkAttachmentDescription2KHR(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentDescription2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkAttachmentReference2KHR(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentReference2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkSubpassDescription2KHR(
+ VulkanHandleMapping* handlemap,
+ VkSubpassDescription2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pInputAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
+ {
+ handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pInputAttachments + i));
+ }
+ }
+ if (toMap->pColorAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
+ {
+ handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pColorAttachments + i));
+ }
+ }
+ if (toMap->pResolveAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
+ {
+ handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pResolveAttachments + i));
+ }
+ }
+ if (toMap->pDepthStencilAttachment)
+ {
+ handlemap_VkAttachmentReference2KHR(handlemap, (VkAttachmentReference2KHR*)(toMap->pDepthStencilAttachment));
+ }
+}
+
+void handlemap_VkSubpassDependency2KHR(
+ VulkanHandleMapping* handlemap,
+ VkSubpassDependency2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkRenderPassCreateInfo2KHR(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassCreateInfo2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
+ {
+ handlemap_VkAttachmentDescription2KHR(handlemap, (VkAttachmentDescription2KHR*)(toMap->pAttachments + i));
+ }
+ }
+ if (toMap->pSubpasses)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
+ {
+ handlemap_VkSubpassDescription2KHR(handlemap, (VkSubpassDescription2KHR*)(toMap->pSubpasses + i));
+ }
+ }
+ if (toMap->pDependencies)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
+ {
+ handlemap_VkSubpassDependency2KHR(handlemap, (VkSubpassDependency2KHR*)(toMap->pDependencies + i));
+ }
+ }
+}
+
+void handlemap_VkSubpassBeginInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSubpassBeginInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkSubpassEndInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSubpassEndInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkSharedPresentSurfaceCapabilitiesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void handlemap_VkImportFenceWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportFenceWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+void handlemap_VkExportFenceWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkExportFenceWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkFenceGetWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkFenceGetWin32HandleInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void handlemap_VkImportFenceFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportFenceFdInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+void handlemap_VkFenceGetFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkFenceGetFdInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
+}
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSurfaceInfo2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
+}
+
+void handlemap_VkSurfaceCapabilities2KHR(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilities2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkSurfaceCapabilitiesKHR(handlemap, (VkSurfaceCapabilitiesKHR*)(&toMap->surfaceCapabilities));
+}
+
+void handlemap_VkSurfaceFormat2KHR(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceFormat2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkSurfaceFormatKHR(handlemap, (VkSurfaceFormatKHR*)(&toMap->surfaceFormat));
+}
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void handlemap_VkDisplayProperties2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayProperties2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkDisplayPropertiesKHR(handlemap, (VkDisplayPropertiesKHR*)(&toMap->displayProperties));
+}
+
+void handlemap_VkDisplayPlaneProperties2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlaneProperties2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkDisplayPlanePropertiesKHR(handlemap, (VkDisplayPlanePropertiesKHR*)(&toMap->displayPlaneProperties));
+}
+
+void handlemap_VkDisplayModeProperties2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayModeProperties2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkDisplayModePropertiesKHR(handlemap, (VkDisplayModePropertiesKHR*)(&toMap->displayModeProperties));
+}
+
+void handlemap_VkDisplayPlaneInfo2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlaneInfo2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->mode);
+}
+
+void handlemap_VkDisplayPlaneCapabilities2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlaneCapabilities2KHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkDisplayPlaneCapabilitiesKHR(handlemap, (VkDisplayPlaneCapabilitiesKHR*)(&toMap->capabilities));
+}
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void handlemap_VkImageFormatListCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImageFormatListCreateInfoKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDevice8BitStorageFeaturesKHR* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void handlemap_VkNativeBufferANDROID(
+ VulkanHandleMapping* handlemap,
+ VkNativeBufferANDROID* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_debug_report
+void handlemap_VkDebugReportCallbackCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugReportCallbackCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
+ VulkanHandleMapping* handlemap,
+ VkPipelineRasterizationStateRasterizationOrderAMD* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void handlemap_VkDebugMarkerObjectNameInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugMarkerObjectNameInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDebugMarkerObjectTagInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugMarkerObjectTagInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDebugMarkerMarkerInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugMarkerMarkerInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void handlemap_VkDedicatedAllocationImageCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkDedicatedAllocationImageCreateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDedicatedAllocationBufferCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkDedicatedAllocationBufferCreateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkDedicatedAllocationMemoryAllocateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void handlemap_VkTextureLODGatherFormatPropertiesAMD(
+ VulkanHandleMapping* handlemap,
+ VkTextureLODGatherFormatPropertiesAMD* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_shader_info
+void handlemap_VkShaderResourceUsageAMD(
+ VulkanHandleMapping* handlemap,
+ VkShaderResourceUsageAMD* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkShaderStatisticsInfoAMD(
+ VulkanHandleMapping* handlemap,
+ VkShaderStatisticsInfoAMD* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkShaderResourceUsageAMD(handlemap, (VkShaderResourceUsageAMD*)(&toMap->resourceUsage));
+}
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void handlemap_VkExternalImageFormatPropertiesNV(
+ VulkanHandleMapping* handlemap,
+ VkExternalImageFormatPropertiesNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
+}
+
+#endif
+#ifdef VK_NV_external_memory
+void handlemap_VkExternalMemoryImageCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkExternalMemoryImageCreateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExportMemoryAllocateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkExportMemoryAllocateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void handlemap_VkImportMemoryWin32HandleInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkImportMemoryWin32HandleInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkExportMemoryWin32HandleInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkExportMemoryWin32HandleInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pAcquireSyncs)
+ {
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
+ }
+ if (toMap->pReleaseSyncs)
+ {
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
+ }
+}
+
+#endif
+#ifdef VK_EXT_validation_flags
+void handlemap_VkValidationFlagsEXT(
+ VulkanHandleMapping* handlemap,
+ VkValidationFlagsEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NN_vi_surface
+void handlemap_VkViSurfaceCreateInfoNN(
+ VulkanHandleMapping* handlemap,
+ VkViSurfaceCreateInfoNN* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void handlemap_VkConditionalRenderingBeginInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkConditionalRenderingBeginInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void handlemap_VkDeviceGeneratedCommandsFeaturesNVX(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGeneratedCommandsFeaturesNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceGeneratedCommandsLimitsNVX(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGeneratedCommandsLimitsNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkIndirectCommandsTokenNVX(
+ VulkanHandleMapping* handlemap,
+ VkIndirectCommandsTokenNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkIndirectCommandsLayoutTokenNVX(
+ VulkanHandleMapping* handlemap,
+ VkIndirectCommandsLayoutTokenNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkIndirectCommandsLayoutCreateInfoNVX(
+ VulkanHandleMapping* handlemap,
+ VkIndirectCommandsLayoutCreateInfoNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pTokens)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->tokenCount; ++i)
+ {
+ handlemap_VkIndirectCommandsLayoutTokenNVX(handlemap, (VkIndirectCommandsLayoutTokenNVX*)(toMap->pTokens + i));
+ }
+ }
+}
+
+void handlemap_VkCmdProcessCommandsInfoNVX(
+ VulkanHandleMapping* handlemap,
+ VkCmdProcessCommandsInfoNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&toMap->objectTable);
+ handlemap->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&toMap->indirectCommandsLayout);
+ if (toMap->pIndirectCommandsTokens)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->indirectCommandsTokenCount; ++i)
+ {
+ handlemap_VkIndirectCommandsTokenNVX(handlemap, (VkIndirectCommandsTokenNVX*)(toMap->pIndirectCommandsTokens + i));
+ }
+ }
+ handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)&toMap->targetCommandBuffer);
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->sequencesCountBuffer);
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->sequencesIndexBuffer);
+}
+
+void handlemap_VkCmdReserveSpaceForCommandsInfoNVX(
+ VulkanHandleMapping* handlemap,
+ VkCmdReserveSpaceForCommandsInfoNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&toMap->objectTable);
+ handlemap->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&toMap->indirectCommandsLayout);
+}
+
+void handlemap_VkObjectTableCreateInfoNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableCreateInfoNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkObjectTableEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableEntryNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkObjectTablePipelineEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTablePipelineEntryNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->pipeline);
+}
+
+void handlemap_VkObjectTableDescriptorSetEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableDescriptorSetEntryNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
+ handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->descriptorSet);
+}
+
+void handlemap_VkObjectTableVertexBufferEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableVertexBufferEntryNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkObjectTableIndexBufferEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableIndexBufferEntryNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkObjectTablePushConstantEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTablePushConstantEntryNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
+}
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void handlemap_VkViewportWScalingNV(
+ VulkanHandleMapping* handlemap,
+ VkViewportWScalingNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkPipelineViewportWScalingStateCreateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pViewportWScalings)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
+ {
+ handlemap_VkViewportWScalingNV(handlemap, (VkViewportWScalingNV*)(toMap->pViewportWScalings + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void handlemap_VkSurfaceCapabilities2EXT(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilities2EXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minImageExtent));
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxImageExtent));
+}
+
+#endif
+#ifdef VK_EXT_display_control
+void handlemap_VkDisplayPowerInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPowerInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDeviceEventInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDeviceEventInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDisplayEventInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDisplayEventInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkSwapchainCounterCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkSwapchainCounterCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void handlemap_VkRefreshCycleDurationGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkRefreshCycleDurationGOOGLE* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPastPresentationTimingGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkPastPresentationTimingGOOGLE* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPresentTimeGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkPresentTimeGOOGLE* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPresentTimesInfoGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkPresentTimesInfoGOOGLE* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pTimes)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i)
+ {
+ handlemap_VkPresentTimeGOOGLE(handlemap, (VkPresentTimeGOOGLE*)(toMap->pTimes + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void handlemap_VkViewportSwizzleNV(
+ VulkanHandleMapping* handlemap,
+ VkViewportSwizzleNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkPipelineViewportSwizzleStateCreateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pViewportSwizzles)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
+ {
+ handlemap_VkViewportSwizzleNV(handlemap, (VkViewportSwizzleNV*)(toMap->pViewportSwizzles + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineDiscardRectangleStateCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pDiscardRectangles)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->discardRectangleCount; ++i)
+ {
+ handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDiscardRectangles + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void handlemap_VkXYColorEXT(
+ VulkanHandleMapping* handlemap,
+ VkXYColorEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkHdrMetadataEXT(
+ VulkanHandleMapping* handlemap,
+ VkHdrMetadataEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryRed));
+ handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryGreen));
+ handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryBlue));
+ handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->whitePoint));
+}
+
+#endif
+#ifdef VK_MVK_ios_surface
+void handlemap_VkIOSSurfaceCreateInfoMVK(
+ VulkanHandleMapping* handlemap,
+ VkIOSSurfaceCreateInfoMVK* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_MVK_macos_surface
+void handlemap_VkMacOSSurfaceCreateInfoMVK(
+ VulkanHandleMapping* handlemap,
+ VkMacOSSurfaceCreateInfoMVK* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void handlemap_VkDebugUtilsObjectNameInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsObjectNameInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDebugUtilsObjectTagInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsObjectTagInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDebugUtilsLabelEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsLabelEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsMessengerCallbackDataEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pQueueLabels)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->queueLabelCount; ++i)
+ {
+ handlemap_VkDebugUtilsLabelEXT(handlemap, (VkDebugUtilsLabelEXT*)(toMap->pQueueLabels + i));
+ }
+ }
+ if (toMap->pCmdBufLabels)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->cmdBufLabelCount; ++i)
+ {
+ handlemap_VkDebugUtilsLabelEXT(handlemap, (VkDebugUtilsLabelEXT*)(toMap->pCmdBufLabels + i));
+ }
+ }
+ if (toMap->pObjects)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->objectCount; ++i)
+ {
+ handlemap_VkDebugUtilsObjectNameInfoEXT(handlemap, (VkDebugUtilsObjectNameInfoEXT*)(toMap->pObjects + i));
+ }
+ }
+}
+
+void handlemap_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsMessengerCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void handlemap_VkAndroidHardwareBufferUsageANDROID(
+ VulkanHandleMapping* handlemap,
+ VkAndroidHardwareBufferUsageANDROID* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkAndroidHardwareBufferPropertiesANDROID(
+ VulkanHandleMapping* handlemap,
+ VkAndroidHardwareBufferPropertiesANDROID* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ VulkanHandleMapping* handlemap,
+ VkAndroidHardwareBufferFormatPropertiesANDROID* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
+}
+
+void handlemap_VkImportAndroidHardwareBufferInfoANDROID(
+ VulkanHandleMapping* handlemap,
+ VkImportAndroidHardwareBufferInfoANDROID* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ VulkanHandleMapping* handlemap,
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkExternalFormatANDROID(
+ VulkanHandleMapping* handlemap,
+ VkExternalFormatANDROID* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void handlemap_VkSamplerReductionModeCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkSamplerReductionModeCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void handlemap_VkSampleLocationEXT(
+ VulkanHandleMapping* handlemap,
+ VkSampleLocationEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkSampleLocationsInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkSampleLocationsInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->sampleLocationGridSize));
+ if (toMap->pSampleLocations)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->sampleLocationsCount; ++i)
+ {
+ handlemap_VkSampleLocationEXT(handlemap, (VkSampleLocationEXT*)(toMap->pSampleLocations + i));
+ }
+ }
+}
+
+void handlemap_VkAttachmentSampleLocationsEXT(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentSampleLocationsEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+}
+
+void handlemap_VkSubpassSampleLocationsEXT(
+ VulkanHandleMapping* handlemap,
+ VkSubpassSampleLocationsEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+}
+
+void handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassSampleLocationsBeginInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pAttachmentInitialSampleLocations)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentInitialSampleLocationsCount; ++i)
+ {
+ handlemap_VkAttachmentSampleLocationsEXT(handlemap, (VkAttachmentSampleLocationsEXT*)(toMap->pAttachmentInitialSampleLocations + i));
+ }
+ }
+ if (toMap->pPostSubpassSampleLocations)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->postSubpassSampleLocationsCount; ++i)
+ {
+ handlemap_VkSubpassSampleLocationsEXT(handlemap, (VkSubpassSampleLocationsEXT*)(toMap->pPostSubpassSampleLocations + i));
+ }
+ }
+}
+
+void handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineSampleLocationsStateCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+}
+
+void handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSampleLocationGridSize));
+}
+
+void handlemap_VkMultisamplePropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkMultisamplePropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSampleLocationGridSize));
+}
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkPipelineCoverageToColorStateCreateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkPipelineCoverageModulationStateCreateInfoNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void handlemap_VkValidationCacheCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkValidationCacheCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkShaderModuleValidationCacheCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ handlemap->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&toMap->validationCache);
+}
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDescriptorIndexingFeaturesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDescriptorIndexingPropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void handlemap_VkImportMemoryHostPointerInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkImportMemoryHostPointerInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkMemoryHostPointerPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkMemoryHostPointerPropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceShaderCorePropertiesAMD* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkVertexInputBindingDivisorDescriptionEXT(
+ VulkanHandleMapping* handlemap,
+ VkVertexInputBindingDivisorDescriptionEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+}
+
+void handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+ if (toMap->pVertexBindingDivisors)
+ {
+ for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDivisorCount; ++i)
+ {
+ handlemap_VkVertexInputBindingDivisorDescriptionEXT(handlemap, (VkVertexInputBindingDivisorDescriptionEXT*)(toMap->pVertexBindingDivisors + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void handlemap_VkQueueFamilyCheckpointPropertiesNV(
+ VulkanHandleMapping* handlemap,
+ VkQueueFamilyCheckpointPropertiesNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+void handlemap_VkCheckpointDataNV(
+ VulkanHandleMapping* handlemap,
+ VkCheckpointDataNV* toMap)
+{
+ (void)handlemap;
+ (void)toMap;
+ if (toMap->pNext)
+ {
+ handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+ }
+}
+
+#endif
+void handlemap_extension_struct(
+ VulkanHandleMapping* handlemap,
+ void* structExtension_out)
+{
+ if (!structExtension_out)
+ {
+ return;
+ }
+ uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
+ switch(structType)
+ {
+#ifdef VK_VERSION_1_1
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+ {
+ handlemap_VkPhysicalDeviceSubgroupProperties(handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+ {
+ handlemap_VkPhysicalDevice16BitStorageFeatures(handlemap, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+ {
+ handlemap_VkMemoryDedicatedRequirements(handlemap, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+ {
+ handlemap_VkMemoryDedicatedAllocateInfo(handlemap, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+ {
+ handlemap_VkMemoryAllocateFlagsInfo(handlemap, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+ {
+ handlemap_VkDeviceGroupRenderPassBeginInfo(handlemap, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+ {
+ handlemap_VkDeviceGroupCommandBufferBeginInfo(handlemap, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+ {
+ handlemap_VkDeviceGroupSubmitInfo(handlemap, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+ {
+ handlemap_VkDeviceGroupBindSparseInfo(handlemap, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+ {
+ handlemap_VkBindBufferMemoryDeviceGroupInfo(handlemap, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+ {
+ handlemap_VkBindImageMemoryDeviceGroupInfo(handlemap, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+ {
+ handlemap_VkDeviceGroupDeviceCreateInfo(handlemap, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+ {
+ handlemap_VkPhysicalDeviceFeatures2(handlemap, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+ {
+ handlemap_VkPhysicalDevicePointClippingProperties(handlemap, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+ {
+ handlemap_VkRenderPassInputAttachmentAspectCreateInfo(handlemap, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+ {
+ handlemap_VkImageViewUsageCreateInfo(handlemap, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+ {
+ handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(handlemap, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+ {
+ handlemap_VkRenderPassMultiviewCreateInfo(handlemap, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+ {
+ handlemap_VkPhysicalDeviceMultiviewFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+ {
+ handlemap_VkPhysicalDeviceMultiviewProperties(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+ {
+ handlemap_VkPhysicalDeviceVariablePointerFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+ {
+ handlemap_VkPhysicalDeviceProtectedMemoryFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+ {
+ handlemap_VkPhysicalDeviceProtectedMemoryProperties(handlemap, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+ {
+ handlemap_VkProtectedSubmitInfo(handlemap, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+ {
+ handlemap_VkSamplerYcbcrConversionInfo(handlemap, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+ {
+ handlemap_VkBindImagePlaneMemoryInfo(handlemap, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+ {
+ handlemap_VkImagePlaneMemoryRequirementsInfo(handlemap, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+ {
+ handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+ {
+ handlemap_VkSamplerYcbcrConversionImageFormatProperties(handlemap, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+ {
+ handlemap_VkPhysicalDeviceExternalImageFormatInfo(handlemap, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+ {
+ handlemap_VkExternalImageFormatProperties(handlemap, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+ {
+ handlemap_VkPhysicalDeviceIDProperties(handlemap, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+ {
+ handlemap_VkExternalMemoryImageCreateInfo(handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+ {
+ handlemap_VkExternalMemoryBufferCreateInfo(handlemap, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+ {
+ handlemap_VkExportMemoryAllocateInfo(handlemap, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+ {
+ handlemap_VkExportFenceCreateInfo(handlemap, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+ {
+ handlemap_VkExportSemaphoreCreateInfo(handlemap, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+ {
+ handlemap_VkPhysicalDeviceMaintenance3Properties(handlemap, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+ {
+ handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_swapchain
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+ {
+ handlemap_VkImageSwapchainCreateInfoKHR(handlemap, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+ {
+ handlemap_VkBindImageMemorySwapchainInfoKHR(handlemap, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+ {
+ handlemap_VkDeviceGroupPresentInfoKHR(handlemap, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+ {
+ handlemap_VkDeviceGroupSwapchainCreateInfoKHR(handlemap, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_display_swapchain
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+ {
+ handlemap_VkDisplayPresentInfoKHR(handlemap, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_external_memory_win32
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ {
+ handlemap_VkImportMemoryWin32HandleInfoKHR(handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ {
+ handlemap_VkExportMemoryWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_external_memory_fd
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+ {
+ handlemap_VkImportMemoryFdInfoKHR(handlemap, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+ {
+ handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(handlemap, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+ {
+ handlemap_VkExportSemaphoreWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+ {
+ handlemap_VkD3D12FenceSubmitInfoKHR(handlemap, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_push_descriptor
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+ {
+ handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_incremental_present
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+ {
+ handlemap_VkPresentRegionsKHR(handlemap, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+ {
+ handlemap_VkSharedPresentSurfaceCapabilitiesKHR(handlemap, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_external_fence_win32
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+ {
+ handlemap_VkExportFenceWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_image_format_list
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+ {
+ handlemap_VkImageFormatListCreateInfoKHR(handlemap, reinterpret_cast<VkImageFormatListCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_8bit_storage
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+ {
+ handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_ANDROID_native_buffer
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+ {
+ handlemap_VkNativeBufferANDROID(handlemap, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_debug_report
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+ {
+ handlemap_VkDebugReportCallbackCreateInfoEXT(handlemap, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_AMD_rasterization_order
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+ {
+ handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(handlemap, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_dedicated_allocation
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+ {
+ handlemap_VkDedicatedAllocationImageCreateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+ {
+ handlemap_VkDedicatedAllocationBufferCreateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+ {
+ handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+ {
+ handlemap_VkTextureLODGatherFormatPropertiesAMD(handlemap, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_external_memory
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+ {
+ handlemap_VkExternalMemoryImageCreateInfoNV(handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+ {
+ handlemap_VkExportMemoryAllocateInfoNV(handlemap, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_external_memory_win32
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ {
+ handlemap_VkImportMemoryWin32HandleInfoNV(handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ {
+ handlemap_VkExportMemoryWin32HandleInfoNV(handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+ {
+ handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(handlemap, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_validation_flags
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+ {
+ handlemap_VkValidationFlagsEXT(handlemap, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_conditional_rendering
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+ {
+ handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+ {
+ handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(handlemap, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+ {
+ handlemap_VkPipelineViewportWScalingStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_display_control
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+ {
+ handlemap_VkSwapchainCounterCreateInfoEXT(handlemap, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_GOOGLE_display_timing
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+ {
+ handlemap_VkPresentTimesInfoGOOGLE(handlemap, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+ {
+ handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_viewport_swizzle
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+ {
+ handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_discard_rectangles
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+ {
+ handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+ {
+ handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_conservative_rasterization
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+ {
+ handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+ {
+ handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+ {
+ handlemap_VkDebugUtilsMessengerCreateInfoEXT(handlemap, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+ {
+ handlemap_VkAndroidHardwareBufferUsageANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+ {
+ handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+ {
+ handlemap_VkImportAndroidHardwareBufferInfoANDROID(handlemap, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+ {
+ handlemap_VkExternalFormatANDROID(handlemap, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+ {
+ handlemap_VkSamplerReductionModeCreateInfoEXT(handlemap, reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+ {
+ handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_sample_locations
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+ {
+ handlemap_VkSampleLocationsInfoEXT(handlemap, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+ {
+ handlemap_VkRenderPassSampleLocationsBeginInfoEXT(handlemap, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+ {
+ handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+ {
+ handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+ {
+ handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+ {
+ handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+ {
+ handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+ {
+ handlemap_VkPipelineCoverageToColorStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+ {
+ handlemap_VkPipelineCoverageModulationStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_validation_cache
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+ {
+ handlemap_VkShaderModuleValidationCacheCreateInfoEXT(handlemap, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+ {
+ handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(handlemap, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+ {
+ handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+ {
+ handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+ {
+ handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+ {
+ handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_global_priority
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+ {
+ handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(handlemap, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_external_memory_host
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+ {
+ handlemap_VkImportMemoryHostPointerInfoEXT(handlemap, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+ {
+ handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_AMD_shader_core_properties
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+ {
+ handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(handlemap, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+ {
+ handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+ {
+ handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+ {
+ handlemap_VkQueueFamilyCheckpointPropertiesNV(handlemap, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+ break;
+ }
+#endif
+ default:
+ {
+ return;
+ }
+ }
+}
+
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
new file mode 100644
index 0000000..d961965
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
@@ -0,0 +1,1667 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_handlemap_guest
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "vk_platform_compat.h"
+
+#include "goldfish_vk_private_defs.h"
+#include "VulkanHandleMapping.h"
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+void handlemap_VkApplicationInfo(
+ VulkanHandleMapping* handlemap,
+ VkApplicationInfo* toMap);
+
+void handlemap_VkInstanceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkInstanceCreateInfo* toMap);
+
+void handlemap_VkAllocationCallbacks(
+ VulkanHandleMapping* handlemap,
+ VkAllocationCallbacks* toMap);
+
+void handlemap_VkPhysicalDeviceFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceFeatures* toMap);
+
+void handlemap_VkFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkFormatProperties* toMap);
+
+void handlemap_VkExtent3D(
+ VulkanHandleMapping* handlemap,
+ VkExtent3D* toMap);
+
+void handlemap_VkImageFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkImageFormatProperties* toMap);
+
+void handlemap_VkPhysicalDeviceLimits(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceLimits* toMap);
+
+void handlemap_VkPhysicalDeviceSparseProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSparseProperties* toMap);
+
+void handlemap_VkPhysicalDeviceProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProperties* toMap);
+
+void handlemap_VkQueueFamilyProperties(
+ VulkanHandleMapping* handlemap,
+ VkQueueFamilyProperties* toMap);
+
+void handlemap_VkMemoryType(
+ VulkanHandleMapping* handlemap,
+ VkMemoryType* toMap);
+
+void handlemap_VkMemoryHeap(
+ VulkanHandleMapping* handlemap,
+ VkMemoryHeap* toMap);
+
+void handlemap_VkPhysicalDeviceMemoryProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMemoryProperties* toMap);
+
+void handlemap_VkDeviceQueueCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceQueueCreateInfo* toMap);
+
+void handlemap_VkDeviceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceCreateInfo* toMap);
+
+void handlemap_VkExtensionProperties(
+ VulkanHandleMapping* handlemap,
+ VkExtensionProperties* toMap);
+
+void handlemap_VkLayerProperties(
+ VulkanHandleMapping* handlemap,
+ VkLayerProperties* toMap);
+
+void handlemap_VkSubmitInfo(
+ VulkanHandleMapping* handlemap,
+ VkSubmitInfo* toMap);
+
+void handlemap_VkMemoryAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkMemoryAllocateInfo* toMap);
+
+void handlemap_VkMappedMemoryRange(
+ VulkanHandleMapping* handlemap,
+ VkMappedMemoryRange* toMap);
+
+void handlemap_VkMemoryRequirements(
+ VulkanHandleMapping* handlemap,
+ VkMemoryRequirements* toMap);
+
+void handlemap_VkSparseImageFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageFormatProperties* toMap);
+
+void handlemap_VkSparseImageMemoryRequirements(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryRequirements* toMap);
+
+void handlemap_VkSparseMemoryBind(
+ VulkanHandleMapping* handlemap,
+ VkSparseMemoryBind* toMap);
+
+void handlemap_VkSparseBufferMemoryBindInfo(
+ VulkanHandleMapping* handlemap,
+ VkSparseBufferMemoryBindInfo* toMap);
+
+void handlemap_VkSparseImageOpaqueMemoryBindInfo(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageOpaqueMemoryBindInfo* toMap);
+
+void handlemap_VkImageSubresource(
+ VulkanHandleMapping* handlemap,
+ VkImageSubresource* toMap);
+
+void handlemap_VkOffset3D(
+ VulkanHandleMapping* handlemap,
+ VkOffset3D* toMap);
+
+void handlemap_VkSparseImageMemoryBind(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryBind* toMap);
+
+void handlemap_VkSparseImageMemoryBindInfo(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryBindInfo* toMap);
+
+void handlemap_VkBindSparseInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindSparseInfo* toMap);
+
+void handlemap_VkFenceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkFenceCreateInfo* toMap);
+
+void handlemap_VkSemaphoreCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkSemaphoreCreateInfo* toMap);
+
+void handlemap_VkEventCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkEventCreateInfo* toMap);
+
+void handlemap_VkQueryPoolCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkQueryPoolCreateInfo* toMap);
+
+void handlemap_VkBufferCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkBufferCreateInfo* toMap);
+
+void handlemap_VkBufferViewCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkBufferViewCreateInfo* toMap);
+
+void handlemap_VkImageCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkImageCreateInfo* toMap);
+
+void handlemap_VkSubresourceLayout(
+ VulkanHandleMapping* handlemap,
+ VkSubresourceLayout* toMap);
+
+void handlemap_VkComponentMapping(
+ VulkanHandleMapping* handlemap,
+ VkComponentMapping* toMap);
+
+void handlemap_VkImageSubresourceRange(
+ VulkanHandleMapping* handlemap,
+ VkImageSubresourceRange* toMap);
+
+void handlemap_VkImageViewCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkImageViewCreateInfo* toMap);
+
+void handlemap_VkShaderModuleCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkShaderModuleCreateInfo* toMap);
+
+void handlemap_VkPipelineCacheCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineCacheCreateInfo* toMap);
+
+void handlemap_VkSpecializationMapEntry(
+ VulkanHandleMapping* handlemap,
+ VkSpecializationMapEntry* toMap);
+
+void handlemap_VkSpecializationInfo(
+ VulkanHandleMapping* handlemap,
+ VkSpecializationInfo* toMap);
+
+void handlemap_VkPipelineShaderStageCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineShaderStageCreateInfo* toMap);
+
+void handlemap_VkVertexInputBindingDescription(
+ VulkanHandleMapping* handlemap,
+ VkVertexInputBindingDescription* toMap);
+
+void handlemap_VkVertexInputAttributeDescription(
+ VulkanHandleMapping* handlemap,
+ VkVertexInputAttributeDescription* toMap);
+
+void handlemap_VkPipelineVertexInputStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineVertexInputStateCreateInfo* toMap);
+
+void handlemap_VkPipelineInputAssemblyStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineInputAssemblyStateCreateInfo* toMap);
+
+void handlemap_VkPipelineTessellationStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineTessellationStateCreateInfo* toMap);
+
+void handlemap_VkViewport(
+ VulkanHandleMapping* handlemap,
+ VkViewport* toMap);
+
+void handlemap_VkOffset2D(
+ VulkanHandleMapping* handlemap,
+ VkOffset2D* toMap);
+
+void handlemap_VkExtent2D(
+ VulkanHandleMapping* handlemap,
+ VkExtent2D* toMap);
+
+void handlemap_VkRect2D(
+ VulkanHandleMapping* handlemap,
+ VkRect2D* toMap);
+
+void handlemap_VkPipelineViewportStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineViewportStateCreateInfo* toMap);
+
+void handlemap_VkPipelineRasterizationStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineRasterizationStateCreateInfo* toMap);
+
+void handlemap_VkPipelineMultisampleStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineMultisampleStateCreateInfo* toMap);
+
+void handlemap_VkStencilOpState(
+ VulkanHandleMapping* handlemap,
+ VkStencilOpState* toMap);
+
+void handlemap_VkPipelineDepthStencilStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineDepthStencilStateCreateInfo* toMap);
+
+void handlemap_VkPipelineColorBlendAttachmentState(
+ VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendAttachmentState* toMap);
+
+void handlemap_VkPipelineColorBlendStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendStateCreateInfo* toMap);
+
+void handlemap_VkPipelineDynamicStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineDynamicStateCreateInfo* toMap);
+
+void handlemap_VkGraphicsPipelineCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkGraphicsPipelineCreateInfo* toMap);
+
+void handlemap_VkComputePipelineCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkComputePipelineCreateInfo* toMap);
+
+void handlemap_VkPushConstantRange(
+ VulkanHandleMapping* handlemap,
+ VkPushConstantRange* toMap);
+
+void handlemap_VkPipelineLayoutCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineLayoutCreateInfo* toMap);
+
+void handlemap_VkSamplerCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkSamplerCreateInfo* toMap);
+
+void handlemap_VkDescriptorSetLayoutBinding(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutBinding* toMap);
+
+void handlemap_VkDescriptorSetLayoutCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutCreateInfo* toMap);
+
+void handlemap_VkDescriptorPoolSize(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorPoolSize* toMap);
+
+void handlemap_VkDescriptorPoolCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorPoolCreateInfo* toMap);
+
+void handlemap_VkDescriptorSetAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetAllocateInfo* toMap);
+
+void handlemap_VkDescriptorImageInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorImageInfo* toMap);
+
+void handlemap_VkDescriptorBufferInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorBufferInfo* toMap);
+
+void handlemap_VkWriteDescriptorSet(
+ VulkanHandleMapping* handlemap,
+ VkWriteDescriptorSet* toMap);
+
+void handlemap_VkCopyDescriptorSet(
+ VulkanHandleMapping* handlemap,
+ VkCopyDescriptorSet* toMap);
+
+void handlemap_VkFramebufferCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkFramebufferCreateInfo* toMap);
+
+void handlemap_VkAttachmentDescription(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentDescription* toMap);
+
+void handlemap_VkAttachmentReference(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentReference* toMap);
+
+void handlemap_VkSubpassDescription(
+ VulkanHandleMapping* handlemap,
+ VkSubpassDescription* toMap);
+
+void handlemap_VkSubpassDependency(
+ VulkanHandleMapping* handlemap,
+ VkSubpassDependency* toMap);
+
+void handlemap_VkRenderPassCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassCreateInfo* toMap);
+
+void handlemap_VkCommandPoolCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkCommandPoolCreateInfo* toMap);
+
+void handlemap_VkCommandBufferAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkCommandBufferAllocateInfo* toMap);
+
+void handlemap_VkCommandBufferInheritanceInfo(
+ VulkanHandleMapping* handlemap,
+ VkCommandBufferInheritanceInfo* toMap);
+
+void handlemap_VkCommandBufferBeginInfo(
+ VulkanHandleMapping* handlemap,
+ VkCommandBufferBeginInfo* toMap);
+
+void handlemap_VkBufferCopy(
+ VulkanHandleMapping* handlemap,
+ VkBufferCopy* toMap);
+
+void handlemap_VkImageSubresourceLayers(
+ VulkanHandleMapping* handlemap,
+ VkImageSubresourceLayers* toMap);
+
+void handlemap_VkImageCopy(
+ VulkanHandleMapping* handlemap,
+ VkImageCopy* toMap);
+
+void handlemap_VkImageBlit(
+ VulkanHandleMapping* handlemap,
+ VkImageBlit* toMap);
+
+void handlemap_VkBufferImageCopy(
+ VulkanHandleMapping* handlemap,
+ VkBufferImageCopy* toMap);
+
+void handlemap_VkClearColorValue(
+ VulkanHandleMapping* handlemap,
+ VkClearColorValue* toMap);
+
+void handlemap_VkClearDepthStencilValue(
+ VulkanHandleMapping* handlemap,
+ VkClearDepthStencilValue* toMap);
+
+void handlemap_VkClearValue(
+ VulkanHandleMapping* handlemap,
+ VkClearValue* toMap);
+
+void handlemap_VkClearAttachment(
+ VulkanHandleMapping* handlemap,
+ VkClearAttachment* toMap);
+
+void handlemap_VkClearRect(
+ VulkanHandleMapping* handlemap,
+ VkClearRect* toMap);
+
+void handlemap_VkImageResolve(
+ VulkanHandleMapping* handlemap,
+ VkImageResolve* toMap);
+
+void handlemap_VkMemoryBarrier(
+ VulkanHandleMapping* handlemap,
+ VkMemoryBarrier* toMap);
+
+void handlemap_VkBufferMemoryBarrier(
+ VulkanHandleMapping* handlemap,
+ VkBufferMemoryBarrier* toMap);
+
+void handlemap_VkImageMemoryBarrier(
+ VulkanHandleMapping* handlemap,
+ VkImageMemoryBarrier* toMap);
+
+void handlemap_VkRenderPassBeginInfo(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassBeginInfo* toMap);
+
+void handlemap_VkDispatchIndirectCommand(
+ VulkanHandleMapping* handlemap,
+ VkDispatchIndirectCommand* toMap);
+
+void handlemap_VkDrawIndexedIndirectCommand(
+ VulkanHandleMapping* handlemap,
+ VkDrawIndexedIndirectCommand* toMap);
+
+void handlemap_VkDrawIndirectCommand(
+ VulkanHandleMapping* handlemap,
+ VkDrawIndirectCommand* toMap);
+
+void handlemap_VkBaseOutStructure(
+ VulkanHandleMapping* handlemap,
+ VkBaseOutStructure* toMap);
+
+void handlemap_VkBaseInStructure(
+ VulkanHandleMapping* handlemap,
+ VkBaseInStructure* toMap);
+
+#endif
+#ifdef VK_VERSION_1_1
+void handlemap_VkPhysicalDeviceSubgroupProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSubgroupProperties* toMap);
+
+void handlemap_VkBindBufferMemoryInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindBufferMemoryInfo* toMap);
+
+void handlemap_VkBindImageMemoryInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindImageMemoryInfo* toMap);
+
+void handlemap_VkPhysicalDevice16BitStorageFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDevice16BitStorageFeatures* toMap);
+
+void handlemap_VkMemoryDedicatedRequirements(
+ VulkanHandleMapping* handlemap,
+ VkMemoryDedicatedRequirements* toMap);
+
+void handlemap_VkMemoryDedicatedAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkMemoryDedicatedAllocateInfo* toMap);
+
+void handlemap_VkMemoryAllocateFlagsInfo(
+ VulkanHandleMapping* handlemap,
+ VkMemoryAllocateFlagsInfo* toMap);
+
+void handlemap_VkDeviceGroupRenderPassBeginInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupRenderPassBeginInfo* toMap);
+
+void handlemap_VkDeviceGroupCommandBufferBeginInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupCommandBufferBeginInfo* toMap);
+
+void handlemap_VkDeviceGroupSubmitInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupSubmitInfo* toMap);
+
+void handlemap_VkDeviceGroupBindSparseInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupBindSparseInfo* toMap);
+
+void handlemap_VkBindBufferMemoryDeviceGroupInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindBufferMemoryDeviceGroupInfo* toMap);
+
+void handlemap_VkBindImageMemoryDeviceGroupInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindImageMemoryDeviceGroupInfo* toMap);
+
+void handlemap_VkPhysicalDeviceGroupProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceGroupProperties* toMap);
+
+void handlemap_VkDeviceGroupDeviceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupDeviceCreateInfo* toMap);
+
+void handlemap_VkBufferMemoryRequirementsInfo2(
+ VulkanHandleMapping* handlemap,
+ VkBufferMemoryRequirementsInfo2* toMap);
+
+void handlemap_VkImageMemoryRequirementsInfo2(
+ VulkanHandleMapping* handlemap,
+ VkImageMemoryRequirementsInfo2* toMap);
+
+void handlemap_VkImageSparseMemoryRequirementsInfo2(
+ VulkanHandleMapping* handlemap,
+ VkImageSparseMemoryRequirementsInfo2* toMap);
+
+void handlemap_VkMemoryRequirements2(
+ VulkanHandleMapping* handlemap,
+ VkMemoryRequirements2* toMap);
+
+void handlemap_VkSparseImageMemoryRequirements2(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryRequirements2* toMap);
+
+void handlemap_VkPhysicalDeviceFeatures2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceFeatures2* toMap);
+
+void handlemap_VkPhysicalDeviceProperties2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProperties2* toMap);
+
+void handlemap_VkFormatProperties2(
+ VulkanHandleMapping* handlemap,
+ VkFormatProperties2* toMap);
+
+void handlemap_VkImageFormatProperties2(
+ VulkanHandleMapping* handlemap,
+ VkImageFormatProperties2* toMap);
+
+void handlemap_VkPhysicalDeviceImageFormatInfo2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceImageFormatInfo2* toMap);
+
+void handlemap_VkQueueFamilyProperties2(
+ VulkanHandleMapping* handlemap,
+ VkQueueFamilyProperties2* toMap);
+
+void handlemap_VkPhysicalDeviceMemoryProperties2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMemoryProperties2* toMap);
+
+void handlemap_VkSparseImageFormatProperties2(
+ VulkanHandleMapping* handlemap,
+ VkSparseImageFormatProperties2* toMap);
+
+void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSparseImageFormatInfo2* toMap);
+
+void handlemap_VkPhysicalDevicePointClippingProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDevicePointClippingProperties* toMap);
+
+void handlemap_VkInputAttachmentAspectReference(
+ VulkanHandleMapping* handlemap,
+ VkInputAttachmentAspectReference* toMap);
+
+void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassInputAttachmentAspectCreateInfo* toMap);
+
+void handlemap_VkImageViewUsageCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkImageViewUsageCreateInfo* toMap);
+
+void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkPipelineTessellationDomainOriginStateCreateInfo* toMap);
+
+void handlemap_VkRenderPassMultiviewCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassMultiviewCreateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceMultiviewFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceMultiviewProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewProperties* toMap);
+
+void handlemap_VkPhysicalDeviceVariablePointerFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVariablePointerFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProtectedMemoryFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProtectedMemoryProperties* toMap);
+
+void handlemap_VkDeviceQueueInfo2(
+ VulkanHandleMapping* handlemap,
+ VkDeviceQueueInfo2* toMap);
+
+void handlemap_VkProtectedSubmitInfo(
+ VulkanHandleMapping* handlemap,
+ VkProtectedSubmitInfo* toMap);
+
+void handlemap_VkSamplerYcbcrConversionCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionCreateInfo* toMap);
+
+void handlemap_VkSamplerYcbcrConversionInfo(
+ VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionInfo* toMap);
+
+void handlemap_VkBindImagePlaneMemoryInfo(
+ VulkanHandleMapping* handlemap,
+ VkBindImagePlaneMemoryInfo* toMap);
+
+void handlemap_VkImagePlaneMemoryRequirementsInfo(
+ VulkanHandleMapping* handlemap,
+ VkImagePlaneMemoryRequirementsInfo* toMap);
+
+void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap);
+
+void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionImageFormatProperties* toMap);
+
+void handlemap_VkDescriptorUpdateTemplateEntry(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorUpdateTemplateEntry* toMap);
+
+void handlemap_VkDescriptorUpdateTemplateCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorUpdateTemplateCreateInfo* toMap);
+
+void handlemap_VkExternalMemoryProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalMemoryProperties* toMap);
+
+void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalImageFormatInfo* toMap);
+
+void handlemap_VkExternalImageFormatProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalImageFormatProperties* toMap);
+
+void handlemap_VkPhysicalDeviceExternalBufferInfo(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalBufferInfo* toMap);
+
+void handlemap_VkExternalBufferProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalBufferProperties* toMap);
+
+void handlemap_VkPhysicalDeviceIDProperties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceIDProperties* toMap);
+
+void handlemap_VkExternalMemoryImageCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExternalMemoryImageCreateInfo* toMap);
+
+void handlemap_VkExternalMemoryBufferCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExternalMemoryBufferCreateInfo* toMap);
+
+void handlemap_VkExportMemoryAllocateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExportMemoryAllocateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceExternalFenceInfo(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalFenceInfo* toMap);
+
+void handlemap_VkExternalFenceProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalFenceProperties* toMap);
+
+void handlemap_VkExportFenceCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExportFenceCreateInfo* toMap);
+
+void handlemap_VkExportSemaphoreCreateInfo(
+ VulkanHandleMapping* handlemap,
+ VkExportSemaphoreCreateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalSemaphoreInfo* toMap);
+
+void handlemap_VkExternalSemaphoreProperties(
+ VulkanHandleMapping* handlemap,
+ VkExternalSemaphoreProperties* toMap);
+
+void handlemap_VkPhysicalDeviceMaintenance3Properties(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMaintenance3Properties* toMap);
+
+void handlemap_VkDescriptorSetLayoutSupport(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutSupport* toMap);
+
+void handlemap_VkPhysicalDeviceShaderDrawParameterFeatures(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceShaderDrawParameterFeatures* toMap);
+
+#endif
+#ifdef VK_KHR_surface
+void handlemap_VkSurfaceCapabilitiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilitiesKHR* toMap);
+
+void handlemap_VkSurfaceFormatKHR(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceFormatKHR* toMap);
+
+#endif
+#ifdef VK_KHR_swapchain
+void handlemap_VkSwapchainCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSwapchainCreateInfoKHR* toMap);
+
+void handlemap_VkPresentInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkPresentInfoKHR* toMap);
+
+void handlemap_VkImageSwapchainCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImageSwapchainCreateInfoKHR* toMap);
+
+void handlemap_VkBindImageMemorySwapchainInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkBindImageMemorySwapchainInfoKHR* toMap);
+
+void handlemap_VkAcquireNextImageInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkAcquireNextImageInfoKHR* toMap);
+
+void handlemap_VkDeviceGroupPresentCapabilitiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupPresentCapabilitiesKHR* toMap);
+
+void handlemap_VkDeviceGroupPresentInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupPresentInfoKHR* toMap);
+
+void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGroupSwapchainCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_display
+void handlemap_VkDisplayPropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPropertiesKHR* toMap);
+
+void handlemap_VkDisplayModeParametersKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayModeParametersKHR* toMap);
+
+void handlemap_VkDisplayModePropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayModePropertiesKHR* toMap);
+
+void handlemap_VkDisplayModeCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayModeCreateInfoKHR* toMap);
+
+void handlemap_VkDisplayPlaneCapabilitiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlaneCapabilitiesKHR* toMap);
+
+void handlemap_VkDisplayPlanePropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlanePropertiesKHR* toMap);
+
+void handlemap_VkDisplaySurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplaySurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void handlemap_VkDisplayPresentInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPresentInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void handlemap_VkXlibSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkXlibSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void handlemap_VkXcbSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkXcbSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void handlemap_VkWaylandSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkWaylandSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_mir_surface
+void handlemap_VkMirSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkMirSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_android_surface
+void handlemap_VkAndroidSurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkAndroidSurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_win32_surface
+void handlemap_VkWin32SurfaceCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkWin32SurfaceCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void handlemap_VkImportMemoryWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportMemoryWin32HandleInfoKHR* toMap);
+
+void handlemap_VkExportMemoryWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkExportMemoryWin32HandleInfoKHR* toMap);
+
+void handlemap_VkMemoryWin32HandlePropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkMemoryWin32HandlePropertiesKHR* toMap);
+
+void handlemap_VkMemoryGetWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkMemoryGetWin32HandleInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void handlemap_VkImportMemoryFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportMemoryFdInfoKHR* toMap);
+
+void handlemap_VkMemoryFdPropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkMemoryFdPropertiesKHR* toMap);
+
+void handlemap_VkMemoryGetFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkMemoryGetFdInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void handlemap_VkImportSemaphoreWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportSemaphoreWin32HandleInfoKHR* toMap);
+
+void handlemap_VkExportSemaphoreWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkExportSemaphoreWin32HandleInfoKHR* toMap);
+
+void handlemap_VkD3D12FenceSubmitInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkD3D12FenceSubmitInfoKHR* toMap);
+
+void handlemap_VkSemaphoreGetWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSemaphoreGetWin32HandleInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void handlemap_VkImportSemaphoreFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportSemaphoreFdInfoKHR* toMap);
+
+void handlemap_VkSemaphoreGetFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSemaphoreGetFdInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDevicePushDescriptorPropertiesKHR* toMap);
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void handlemap_VkRectLayerKHR(
+ VulkanHandleMapping* handlemap,
+ VkRectLayerKHR* toMap);
+
+void handlemap_VkPresentRegionKHR(
+ VulkanHandleMapping* handlemap,
+ VkPresentRegionKHR* toMap);
+
+void handlemap_VkPresentRegionsKHR(
+ VulkanHandleMapping* handlemap,
+ VkPresentRegionsKHR* toMap);
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void handlemap_VkAttachmentDescription2KHR(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentDescription2KHR* toMap);
+
+void handlemap_VkAttachmentReference2KHR(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentReference2KHR* toMap);
+
+void handlemap_VkSubpassDescription2KHR(
+ VulkanHandleMapping* handlemap,
+ VkSubpassDescription2KHR* toMap);
+
+void handlemap_VkSubpassDependency2KHR(
+ VulkanHandleMapping* handlemap,
+ VkSubpassDependency2KHR* toMap);
+
+void handlemap_VkRenderPassCreateInfo2KHR(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassCreateInfo2KHR* toMap);
+
+void handlemap_VkSubpassBeginInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSubpassBeginInfoKHR* toMap);
+
+void handlemap_VkSubpassEndInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkSubpassEndInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(
+ VulkanHandleMapping* handlemap,
+ VkSharedPresentSurfaceCapabilitiesKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void handlemap_VkImportFenceWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportFenceWin32HandleInfoKHR* toMap);
+
+void handlemap_VkExportFenceWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkExportFenceWin32HandleInfoKHR* toMap);
+
+void handlemap_VkFenceGetWin32HandleInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkFenceGetWin32HandleInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void handlemap_VkImportFenceFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImportFenceFdInfoKHR* toMap);
+
+void handlemap_VkFenceGetFdInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkFenceGetFdInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSurfaceInfo2KHR* toMap);
+
+void handlemap_VkSurfaceCapabilities2KHR(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilities2KHR* toMap);
+
+void handlemap_VkSurfaceFormat2KHR(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceFormat2KHR* toMap);
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void handlemap_VkDisplayProperties2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayProperties2KHR* toMap);
+
+void handlemap_VkDisplayPlaneProperties2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlaneProperties2KHR* toMap);
+
+void handlemap_VkDisplayModeProperties2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayModeProperties2KHR* toMap);
+
+void handlemap_VkDisplayPlaneInfo2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlaneInfo2KHR* toMap);
+
+void handlemap_VkDisplayPlaneCapabilities2KHR(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPlaneCapabilities2KHR* toMap);
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void handlemap_VkImageFormatListCreateInfoKHR(
+ VulkanHandleMapping* handlemap,
+ VkImageFormatListCreateInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void handlemap_VkPhysicalDevice8BitStorageFeaturesKHR(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDevice8BitStorageFeaturesKHR* toMap);
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void handlemap_VkNativeBufferANDROID(
+ VulkanHandleMapping* handlemap,
+ VkNativeBufferANDROID* toMap);
+
+#endif
+#ifdef VK_EXT_debug_report
+void handlemap_VkDebugReportCallbackCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugReportCallbackCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
+ VulkanHandleMapping* handlemap,
+ VkPipelineRasterizationStateRasterizationOrderAMD* toMap);
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void handlemap_VkDebugMarkerObjectNameInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugMarkerObjectNameInfoEXT* toMap);
+
+void handlemap_VkDebugMarkerObjectTagInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugMarkerObjectTagInfoEXT* toMap);
+
+void handlemap_VkDebugMarkerMarkerInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugMarkerMarkerInfoEXT* toMap);
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void handlemap_VkDedicatedAllocationImageCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkDedicatedAllocationImageCreateInfoNV* toMap);
+
+void handlemap_VkDedicatedAllocationBufferCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkDedicatedAllocationBufferCreateInfoNV* toMap);
+
+void handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkDedicatedAllocationMemoryAllocateInfoNV* toMap);
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void handlemap_VkTextureLODGatherFormatPropertiesAMD(
+ VulkanHandleMapping* handlemap,
+ VkTextureLODGatherFormatPropertiesAMD* toMap);
+
+#endif
+#ifdef VK_AMD_shader_info
+void handlemap_VkShaderResourceUsageAMD(
+ VulkanHandleMapping* handlemap,
+ VkShaderResourceUsageAMD* toMap);
+
+void handlemap_VkShaderStatisticsInfoAMD(
+ VulkanHandleMapping* handlemap,
+ VkShaderStatisticsInfoAMD* toMap);
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void handlemap_VkExternalImageFormatPropertiesNV(
+ VulkanHandleMapping* handlemap,
+ VkExternalImageFormatPropertiesNV* toMap);
+
+#endif
+#ifdef VK_NV_external_memory
+void handlemap_VkExternalMemoryImageCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkExternalMemoryImageCreateInfoNV* toMap);
+
+void handlemap_VkExportMemoryAllocateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkExportMemoryAllocateInfoNV* toMap);
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void handlemap_VkImportMemoryWin32HandleInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkImportMemoryWin32HandleInfoNV* toMap);
+
+void handlemap_VkExportMemoryWin32HandleInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkExportMemoryWin32HandleInfoNV* toMap);
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* toMap);
+
+#endif
+#ifdef VK_EXT_validation_flags
+void handlemap_VkValidationFlagsEXT(
+ VulkanHandleMapping* handlemap,
+ VkValidationFlagsEXT* toMap);
+
+#endif
+#ifdef VK_NN_vi_surface
+void handlemap_VkViSurfaceCreateInfoNN(
+ VulkanHandleMapping* handlemap,
+ VkViSurfaceCreateInfoNN* toMap);
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void handlemap_VkConditionalRenderingBeginInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkConditionalRenderingBeginInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap);
+
+void handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap);
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void handlemap_VkDeviceGeneratedCommandsFeaturesNVX(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGeneratedCommandsFeaturesNVX* toMap);
+
+void handlemap_VkDeviceGeneratedCommandsLimitsNVX(
+ VulkanHandleMapping* handlemap,
+ VkDeviceGeneratedCommandsLimitsNVX* toMap);
+
+void handlemap_VkIndirectCommandsTokenNVX(
+ VulkanHandleMapping* handlemap,
+ VkIndirectCommandsTokenNVX* toMap);
+
+void handlemap_VkIndirectCommandsLayoutTokenNVX(
+ VulkanHandleMapping* handlemap,
+ VkIndirectCommandsLayoutTokenNVX* toMap);
+
+void handlemap_VkIndirectCommandsLayoutCreateInfoNVX(
+ VulkanHandleMapping* handlemap,
+ VkIndirectCommandsLayoutCreateInfoNVX* toMap);
+
+void handlemap_VkCmdProcessCommandsInfoNVX(
+ VulkanHandleMapping* handlemap,
+ VkCmdProcessCommandsInfoNVX* toMap);
+
+void handlemap_VkCmdReserveSpaceForCommandsInfoNVX(
+ VulkanHandleMapping* handlemap,
+ VkCmdReserveSpaceForCommandsInfoNVX* toMap);
+
+void handlemap_VkObjectTableCreateInfoNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableCreateInfoNVX* toMap);
+
+void handlemap_VkObjectTableEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableEntryNVX* toMap);
+
+void handlemap_VkObjectTablePipelineEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTablePipelineEntryNVX* toMap);
+
+void handlemap_VkObjectTableDescriptorSetEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableDescriptorSetEntryNVX* toMap);
+
+void handlemap_VkObjectTableVertexBufferEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableVertexBufferEntryNVX* toMap);
+
+void handlemap_VkObjectTableIndexBufferEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTableIndexBufferEntryNVX* toMap);
+
+void handlemap_VkObjectTablePushConstantEntryNVX(
+ VulkanHandleMapping* handlemap,
+ VkObjectTablePushConstantEntryNVX* toMap);
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void handlemap_VkViewportWScalingNV(
+ VulkanHandleMapping* handlemap,
+ VkViewportWScalingNV* toMap);
+
+void handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkPipelineViewportWScalingStateCreateInfoNV* toMap);
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void handlemap_VkSurfaceCapabilities2EXT(
+ VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilities2EXT* toMap);
+
+#endif
+#ifdef VK_EXT_display_control
+void handlemap_VkDisplayPowerInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDisplayPowerInfoEXT* toMap);
+
+void handlemap_VkDeviceEventInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDeviceEventInfoEXT* toMap);
+
+void handlemap_VkDisplayEventInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDisplayEventInfoEXT* toMap);
+
+void handlemap_VkSwapchainCounterCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkSwapchainCounterCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void handlemap_VkRefreshCycleDurationGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkRefreshCycleDurationGOOGLE* toMap);
+
+void handlemap_VkPastPresentationTimingGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkPastPresentationTimingGOOGLE* toMap);
+
+void handlemap_VkPresentTimeGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkPresentTimeGOOGLE* toMap);
+
+void handlemap_VkPresentTimesInfoGOOGLE(
+ VulkanHandleMapping* handlemap,
+ VkPresentTimesInfoGOOGLE* toMap);
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap);
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void handlemap_VkViewportSwizzleNV(
+ VulkanHandleMapping* handlemap,
+ VkViewportSwizzleNV* toMap);
+
+void handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkPipelineViewportSwizzleStateCreateInfoNV* toMap);
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap);
+
+void handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineDiscardRectangleStateCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap);
+
+void handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void handlemap_VkXYColorEXT(
+ VulkanHandleMapping* handlemap,
+ VkXYColorEXT* toMap);
+
+void handlemap_VkHdrMetadataEXT(
+ VulkanHandleMapping* handlemap,
+ VkHdrMetadataEXT* toMap);
+
+#endif
+#ifdef VK_MVK_ios_surface
+void handlemap_VkIOSSurfaceCreateInfoMVK(
+ VulkanHandleMapping* handlemap,
+ VkIOSSurfaceCreateInfoMVK* toMap);
+
+#endif
+#ifdef VK_MVK_macos_surface
+void handlemap_VkMacOSSurfaceCreateInfoMVK(
+ VulkanHandleMapping* handlemap,
+ VkMacOSSurfaceCreateInfoMVK* toMap);
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void handlemap_VkDebugUtilsObjectNameInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsObjectNameInfoEXT* toMap);
+
+void handlemap_VkDebugUtilsObjectTagInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsObjectTagInfoEXT* toMap);
+
+void handlemap_VkDebugUtilsLabelEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsLabelEXT* toMap);
+
+void handlemap_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsMessengerCallbackDataEXT* toMap);
+
+void handlemap_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDebugUtilsMessengerCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void handlemap_VkAndroidHardwareBufferUsageANDROID(
+ VulkanHandleMapping* handlemap,
+ VkAndroidHardwareBufferUsageANDROID* toMap);
+
+void handlemap_VkAndroidHardwareBufferPropertiesANDROID(
+ VulkanHandleMapping* handlemap,
+ VkAndroidHardwareBufferPropertiesANDROID* toMap);
+
+void handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ VulkanHandleMapping* handlemap,
+ VkAndroidHardwareBufferFormatPropertiesANDROID* toMap);
+
+void handlemap_VkImportAndroidHardwareBufferInfoANDROID(
+ VulkanHandleMapping* handlemap,
+ VkImportAndroidHardwareBufferInfoANDROID* toMap);
+
+void handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ VulkanHandleMapping* handlemap,
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap);
+
+void handlemap_VkExternalFormatANDROID(
+ VulkanHandleMapping* handlemap,
+ VkExternalFormatANDROID* toMap);
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void handlemap_VkSamplerReductionModeCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkSamplerReductionModeCreateInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* toMap);
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void handlemap_VkSampleLocationEXT(
+ VulkanHandleMapping* handlemap,
+ VkSampleLocationEXT* toMap);
+
+void handlemap_VkSampleLocationsInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkSampleLocationsInfoEXT* toMap);
+
+void handlemap_VkAttachmentSampleLocationsEXT(
+ VulkanHandleMapping* handlemap,
+ VkAttachmentSampleLocationsEXT* toMap);
+
+void handlemap_VkSubpassSampleLocationsEXT(
+ VulkanHandleMapping* handlemap,
+ VkSubpassSampleLocationsEXT* toMap);
+
+void handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkRenderPassSampleLocationsBeginInfoEXT* toMap);
+
+void handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineSampleLocationsStateCreateInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap);
+
+void handlemap_VkMultisamplePropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkMultisamplePropertiesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap);
+
+void handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkPipelineCoverageToColorStateCreateInfoNV* toMap);
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
+ VulkanHandleMapping* handlemap,
+ VkPipelineCoverageModulationStateCreateInfoNV* toMap);
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void handlemap_VkValidationCacheCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkValidationCacheCreateInfoEXT* toMap);
+
+void handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkShaderModuleValidationCacheCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDescriptorIndexingFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDescriptorIndexingPropertiesEXT* toMap);
+
+void handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* toMap);
+
+void handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+ VulkanHandleMapping* handlemap,
+ VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* toMap);
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void handlemap_VkImportMemoryHostPointerInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkImportMemoryHostPointerInfoEXT* toMap);
+
+void handlemap_VkMemoryHostPointerPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkMemoryHostPointerPropertiesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap);
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceShaderCorePropertiesAMD* toMap);
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap);
+
+void handlemap_VkVertexInputBindingDivisorDescriptionEXT(
+ VulkanHandleMapping* handlemap,
+ VkVertexInputBindingDivisorDescriptionEXT* toMap);
+
+void handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ VulkanHandleMapping* handlemap,
+ VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void handlemap_VkQueueFamilyCheckpointPropertiesNV(
+ VulkanHandleMapping* handlemap,
+ VkQueueFamilyCheckpointPropertiesNV* toMap);
+
+void handlemap_VkCheckpointDataNV(
+ VulkanHandleMapping* handlemap,
+ VkCheckpointDataNV* toMap);
+
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
new file mode 100644
index 0000000..1bd5dae
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -0,0 +1,14669 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_marshaling_guest
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "goldfish_vk_marshaling_guest.h"
+
+
+#include "goldfish_vk_extension_structs_guest.h"
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+void marshal_extension_struct(
+ VulkanStream* vkStream,
+ const void* structExtension);
+
+void unmarshal_extension_struct(
+ VulkanStream* vkStream,
+ void* structExtension_out);
+
+#ifdef VK_VERSION_1_0
+void marshal_VkApplicationInfo(
+ VulkanStream* vkStream,
+ const VkApplicationInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->putString(forMarshaling->pApplicationName);
+ vkStream->write((uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
+ vkStream->putString(forMarshaling->pEngineName);
+ vkStream->write((uint32_t*)&forMarshaling->engineVersion, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
+}
+
+void unmarshal_VkApplicationInfo(
+ VulkanStream* vkStream,
+ VkApplicationInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
+ vkStream->read((uint32_t*)&forUnmarshaling->applicationVersion, sizeof(uint32_t));
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
+ vkStream->read((uint32_t*)&forUnmarshaling->engineVersion, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
+}
+
+void marshal_VkInstanceCreateInfo(
+ VulkanStream* vkStream,
+ const VkInstanceCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
+ saveStringArray(vkStream, forMarshaling->ppEnabledLayerNames, forMarshaling->enabledLayerCount);
+ vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
+ saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames, forMarshaling->enabledExtensionCount);
+}
+
+void unmarshal_VkInstanceCreateInfo(
+ VulkanStream* vkStream,
+ VkInstanceCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkInstanceCreateFlags*)&forUnmarshaling->flags, sizeof(VkInstanceCreateFlags));
+ // WARNING PTR CHECK
+ forUnmarshaling->pApplicationInfo = (const VkApplicationInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pApplicationInfo)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pApplicationInfo, sizeof(const VkApplicationInfo));
+ unmarshal_VkApplicationInfo(vkStream, (VkApplicationInfo*)(forUnmarshaling->pApplicationInfo));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
+ vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledLayerNames);
+ vkStream->read((uint32_t*)&forUnmarshaling->enabledExtensionCount, sizeof(uint32_t));
+ vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledExtensionNames);
+}
+
+void marshal_VkAllocationCallbacks(
+ VulkanStream* vkStream,
+ const VkAllocationCallbacks* forMarshaling)
+{
+ // WARNING PTR CHECK
+ uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_2);
+ if (forMarshaling->pUserData)
+ {
+ vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
+ }
+ uint64_t cgen_var_3 = (uint64_t)forMarshaling->pfnAllocation;
+ vkStream->putBe64(cgen_var_3);
+ uint64_t cgen_var_4 = (uint64_t)forMarshaling->pfnReallocation;
+ vkStream->putBe64(cgen_var_4);
+ uint64_t cgen_var_5 = (uint64_t)forMarshaling->pfnFree;
+ vkStream->putBe64(cgen_var_5);
+ uint64_t cgen_var_6 = (uint64_t)forMarshaling->pfnInternalAllocation;
+ vkStream->putBe64(cgen_var_6);
+ uint64_t cgen_var_7 = (uint64_t)forMarshaling->pfnInternalFree;
+ vkStream->putBe64(cgen_var_7);
+}
+
+void unmarshal_VkAllocationCallbacks(
+ VulkanStream* vkStream,
+ VkAllocationCallbacks* forUnmarshaling)
+{
+ // WARNING PTR CHECK
+ forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pUserData)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
+ vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
+ }
+ forUnmarshaling->pfnAllocation = (PFN_vkAllocationFunction)vkStream->getBe64();
+ forUnmarshaling->pfnReallocation = (PFN_vkReallocationFunction)vkStream->getBe64();
+ forUnmarshaling->pfnFree = (PFN_vkFreeFunction)vkStream->getBe64();
+ forUnmarshaling->pfnInternalAllocation = (PFN_vkInternalAllocationNotification)vkStream->getBe64();
+ forUnmarshaling->pfnInternalFree = (PFN_vkInternalFreeNotification)vkStream->getBe64();
+}
+
+void marshal_VkPhysicalDeviceFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceFeatures* forMarshaling)
+{
+ vkStream->write((VkBool32*)&forMarshaling->robustBufferAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fullDrawIndexUint32, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->imageCubeArray, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->independentBlend, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->geometryShader, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->tessellationShader, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sampleRateShading, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->dualSrcBlend, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->logicOp, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->multiDrawIndirect, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->drawIndirectFirstInstance, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->depthClamp, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->depthBiasClamp, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fillModeNonSolid, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->depthBounds, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->wideLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->largePoints, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->alphaToOne, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->multiViewport, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->samplerAnisotropy, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->textureCompressionETC2, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_LDR, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->textureCompressionBC, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->occlusionQueryPrecise, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->pipelineStatisticsQuery, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->vertexPipelineStoresAndAtomics, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderTessellationAndGeometryPointSize, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderImageGatherExtended, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageExtendedFormats, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageMultisample, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageReadWithoutFormat, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageWriteWithoutFormat, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderClipDistance, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderCullDistance, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderFloat64, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInt64, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInt16, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderResourceResidency, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderResourceMinLod, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseBinding, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseResidencyBuffer, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseResidencyImage2D, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseResidencyImage3D, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseResidency2Samples, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseResidency4Samples, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseResidency8Samples, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseResidency16Samples, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->sparseResidencyAliased, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->variableMultisampleRate, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->inheritedQueries, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceFeatures* forUnmarshaling)
+{
+ vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fullDrawIndexUint32, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->imageCubeArray, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->independentBlend, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->geometryShader, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->tessellationShader, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sampleRateShading, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->dualSrcBlend, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->logicOp, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->multiDrawIndirect, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->drawIndirectFirstInstance, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthClamp, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthBiasClamp, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fillModeNonSolid, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthBounds, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->wideLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->largePoints, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->alphaToOne, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->multiViewport, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->samplerAnisotropy, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionETC2, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_LDR, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionBC, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryPrecise, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->pipelineStatisticsQuery, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vertexPipelineStoresAndAtomics, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderTessellationAndGeometryPointSize, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderImageGatherExtended, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageExtendedFormats, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageMultisample, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageReadWithoutFormat, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageWriteWithoutFormat, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderClipDistance, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderCullDistance, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat64, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInt64, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInt16, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderResourceResidency, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderResourceMinLod, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseBinding, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyBuffer, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyImage2D, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyImage3D, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency2Samples, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency4Samples, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency8Samples, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseResidency16Samples, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->sparseResidencyAliased, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->variableMultisampleRate, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->inheritedQueries, sizeof(VkBool32));
+}
+
+void marshal_VkFormatProperties(
+ VulkanStream* vkStream,
+ const VkFormatProperties* forMarshaling)
+{
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags));
+}
+
+void unmarshal_VkFormatProperties(
+ VulkanStream* vkStream,
+ VkFormatProperties* forUnmarshaling)
+{
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags));
+}
+
+void marshal_VkExtent3D(
+ VulkanStream* vkStream,
+ const VkExtent3D* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
+}
+
+void unmarshal_VkExtent3D(
+ VulkanStream* vkStream,
+ VkExtent3D* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
+}
+
+void marshal_VkImageFormatProperties(
+ VulkanStream* vkStream,
+ const VkImageFormatProperties* forMarshaling)
+{
+ marshal_VkExtent3D(vkStream, (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));
+ vkStream->write((VkDeviceSize*)&forMarshaling->maxResourceSize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkImageFormatProperties(
+ VulkanStream* vkStream,
+ VkImageFormatProperties* forUnmarshaling)
+{
+ unmarshal_VkExtent3D(vkStream, (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));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->maxResourceSize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkPhysicalDeviceLimits(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceLimits* forMarshaling)
+{
+ 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));
+ vkStream->write((uint32_t*)&forMarshaling->maxImageDimensionCube, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTexelBufferElements, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxUniformBufferRange, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxStorageBufferRange, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPushConstantsSize, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxMemoryAllocationCount, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxSamplerAllocationCount, sizeof(uint32_t));
+ vkStream->write((VkDeviceSize*)&forMarshaling->bufferImageGranularity, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->sparseAddressSpaceSize, sizeof(VkDeviceSize));
+ vkStream->write((uint32_t*)&forMarshaling->maxBoundDescriptorSets, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSamplers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUniformBuffers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageBuffers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSampledImages, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageImages, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInputAttachments, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageResources, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSamplers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffersDynamic, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffersDynamic, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageImages, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInputAttachments, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxVertexInputAttributes, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxVertexInputBindings, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxVertexInputAttributeOffset, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxVertexInputBindingStride, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxVertexOutputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationGenerationLevel, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationPatchSize, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexInputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexOutputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerPatchOutputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlTotalOutputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationInputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationOutputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxGeometryInputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxGeometryOutputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxGeometryOutputVertices, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxGeometryTotalOutputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxFragmentInputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxFragmentOutputAttachments, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxFragmentDualSrcAttachments, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxFragmentCombinedOutputResources, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxComputeSharedMemorySize, sizeof(uint32_t));
+ vkStream->write((uint32_t*)forMarshaling->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkGroupInvocations, sizeof(uint32_t));
+ vkStream->write((uint32_t*)forMarshaling->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->subPixelPrecisionBits, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->subTexelPrecisionBits, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->mipmapPrecisionBits, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDrawIndexedIndexValue, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDrawIndirectCount, sizeof(uint32_t));
+ vkStream->write((float*)&forMarshaling->maxSamplerLodBias, sizeof(float));
+ vkStream->write((float*)&forMarshaling->maxSamplerAnisotropy, sizeof(float));
+ vkStream->write((uint32_t*)&forMarshaling->maxViewports, sizeof(uint32_t));
+ vkStream->write((uint32_t*)forMarshaling->maxViewportDimensions, 2 * sizeof(uint32_t));
+ vkStream->write((float*)forMarshaling->viewportBoundsRange, 2 * sizeof(float));
+ vkStream->write((uint32_t*)&forMarshaling->viewportSubPixelBits, sizeof(uint32_t));
+ uint64_t cgen_var_14 = (uint64_t)forMarshaling->minMemoryMapAlignment;
+ vkStream->putBe64(cgen_var_14);
+ vkStream->write((VkDeviceSize*)&forMarshaling->minTexelBufferOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->minUniformBufferOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->minStorageBufferOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->write((int32_t*)&forMarshaling->minTexelOffset, sizeof(int32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTexelOffset, sizeof(uint32_t));
+ vkStream->write((int32_t*)&forMarshaling->minTexelGatherOffset, sizeof(int32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTexelGatherOffset, sizeof(uint32_t));
+ vkStream->write((float*)&forMarshaling->minInterpolationOffset, sizeof(float));
+ vkStream->write((float*)&forMarshaling->maxInterpolationOffset, sizeof(float));
+ vkStream->write((uint32_t*)&forMarshaling->subPixelInterpolationOffsetBits, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxFramebufferWidth, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxFramebufferHeight, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxFramebufferLayers, sizeof(uint32_t));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferColorSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferDepthSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferStencilSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferNoAttachmentsSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((uint32_t*)&forMarshaling->maxColorAttachments, sizeof(uint32_t));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageColorSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageIntegerSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageDepthSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageStencilSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->storageImageSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((uint32_t*)&forMarshaling->maxSampleMaskWords, sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->timestampComputeAndGraphics, sizeof(VkBool32));
+ vkStream->write((float*)&forMarshaling->timestampPeriod, sizeof(float));
+ vkStream->write((uint32_t*)&forMarshaling->maxClipDistances, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxCullDistances, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxCombinedClipAndCullDistances, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->discreteQueuePriorities, sizeof(uint32_t));
+ vkStream->write((float*)forMarshaling->pointSizeRange, 2 * sizeof(float));
+ vkStream->write((float*)forMarshaling->lineWidthRange, 2 * sizeof(float));
+ vkStream->write((float*)&forMarshaling->pointSizeGranularity, sizeof(float));
+ vkStream->write((float*)&forMarshaling->lineWidthGranularity, sizeof(float));
+ vkStream->write((VkBool32*)&forMarshaling->strictLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->standardSampleLocations, sizeof(VkBool32));
+ vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyRowPitchAlignment, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceLimits(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceLimits* forUnmarshaling)
+{
+ 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));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimensionCube, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTexelBufferElements, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxUniformBufferRange, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxStorageBufferRange, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPushConstantsSize, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxMemoryAllocationCount, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxSamplerAllocationCount, sizeof(uint32_t));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferImageGranularity, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->sparseAddressSpaceSize, sizeof(VkDeviceSize));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxBoundDescriptorSets, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSamplers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUniformBuffers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageBuffers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSampledImages, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageImages, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInputAttachments, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageResources, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSamplers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffersDynamic, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffersDynamic, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageImages, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInputAttachments, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputAttributes, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputBindings, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputAttributeOffset, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVertexInputBindingStride, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVertexOutputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationGenerationLevel, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationPatchSize, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexInputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexOutputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerPatchOutputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlTotalOutputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationInputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationOutputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryInputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryOutputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryOutputVertices, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryTotalOutputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentInputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentOutputAttachments, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentDualSrcAttachments, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentCombinedOutputResources, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxComputeSharedMemorySize, sizeof(uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkGroupInvocations, sizeof(uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->subPixelPrecisionBits, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->subTexelPrecisionBits, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->mipmapPrecisionBits, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDrawIndexedIndexValue, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDrawIndirectCount, sizeof(uint32_t));
+ vkStream->read((float*)&forUnmarshaling->maxSamplerLodBias, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->maxSamplerAnisotropy, sizeof(float));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxViewports, sizeof(uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->maxViewportDimensions, 2 * sizeof(uint32_t));
+ vkStream->read((float*)forUnmarshaling->viewportBoundsRange, 2 * sizeof(float));
+ vkStream->read((uint32_t*)&forUnmarshaling->viewportSubPixelBits, sizeof(uint32_t));
+ forUnmarshaling->minMemoryMapAlignment = (size_t)vkStream->getBe64();
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minTexelBufferOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minUniformBufferOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minStorageBufferOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->read((int32_t*)&forUnmarshaling->minTexelOffset, sizeof(int32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTexelOffset, sizeof(uint32_t));
+ vkStream->read((int32_t*)&forUnmarshaling->minTexelGatherOffset, sizeof(int32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTexelGatherOffset, sizeof(uint32_t));
+ vkStream->read((float*)&forUnmarshaling->minInterpolationOffset, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->maxInterpolationOffset, sizeof(float));
+ vkStream->read((uint32_t*)&forUnmarshaling->subPixelInterpolationOffsetBits, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferWidth, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferHeight, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferLayers, sizeof(uint32_t));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferColorSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferDepthSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferStencilSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferNoAttachmentsSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxColorAttachments, sizeof(uint32_t));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageColorSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageIntegerSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageDepthSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageStencilSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->storageImageSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxSampleMaskWords, sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->timestampComputeAndGraphics, sizeof(VkBool32));
+ vkStream->read((float*)&forUnmarshaling->timestampPeriod, sizeof(float));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxClipDistances, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxCullDistances, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxCombinedClipAndCullDistances, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->discreteQueuePriorities, sizeof(uint32_t));
+ vkStream->read((float*)forUnmarshaling->pointSizeRange, 2 * sizeof(float));
+ vkStream->read((float*)forUnmarshaling->lineWidthRange, 2 * sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->pointSizeGranularity, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->lineWidthGranularity, sizeof(float));
+ vkStream->read((VkBool32*)&forUnmarshaling->strictLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->standardSampleLocations, sizeof(VkBool32));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyRowPitchAlignment, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkPhysicalDeviceSparseProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSparseProperties* forMarshaling)
+{
+ vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DMultisampleBlockShape, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->residencyAlignedMipSize, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->residencyNonResidentStrict, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSparseProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSparseProperties* forUnmarshaling)
+{
+ vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DMultisampleBlockShape, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->residencyAlignedMipSize, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->residencyNonResidentStrict, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceProperties* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->driverVersion, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
+ vkStream->write((VkPhysicalDeviceType*)&forMarshaling->deviceType, sizeof(VkPhysicalDeviceType));
+ vkStream->write((char*)forMarshaling->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
+ vkStream->write((uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+ marshal_VkPhysicalDeviceLimits(vkStream, (VkPhysicalDeviceLimits*)(&forMarshaling->limits));
+ marshal_VkPhysicalDeviceSparseProperties(vkStream, (VkPhysicalDeviceSparseProperties*)(&forMarshaling->sparseProperties));
+}
+
+void unmarshal_VkPhysicalDeviceProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceProperties* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->driverVersion, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->vendorID, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceID, sizeof(uint32_t));
+ vkStream->read((VkPhysicalDeviceType*)&forUnmarshaling->deviceType, sizeof(VkPhysicalDeviceType));
+ vkStream->read((char*)forUnmarshaling->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
+ vkStream->read((uint8_t*)forUnmarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+ unmarshal_VkPhysicalDeviceLimits(vkStream, (VkPhysicalDeviceLimits*)(&forUnmarshaling->limits));
+ unmarshal_VkPhysicalDeviceSparseProperties(vkStream, (VkPhysicalDeviceSparseProperties*)(&forUnmarshaling->sparseProperties));
+}
+
+void marshal_VkQueueFamilyProperties(
+ VulkanStream* vkStream,
+ const VkQueueFamilyProperties* forMarshaling)
+{
+ 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));
+}
+
+void unmarshal_VkQueueFamilyProperties(
+ VulkanStream* vkStream,
+ VkQueueFamilyProperties* forUnmarshaling)
+{
+ 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));
+}
+
+void marshal_VkMemoryType(
+ VulkanStream* vkStream,
+ const VkMemoryType* forMarshaling)
+{
+ vkStream->write((VkMemoryPropertyFlags*)&forMarshaling->propertyFlags, sizeof(VkMemoryPropertyFlags));
+ vkStream->write((uint32_t*)&forMarshaling->heapIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryType(
+ VulkanStream* vkStream,
+ VkMemoryType* forUnmarshaling)
+{
+ vkStream->read((VkMemoryPropertyFlags*)&forUnmarshaling->propertyFlags, sizeof(VkMemoryPropertyFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->heapIndex, sizeof(uint32_t));
+}
+
+void marshal_VkMemoryHeap(
+ VulkanStream* vkStream,
+ const VkMemoryHeap* forMarshaling)
+{
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ vkStream->write((VkMemoryHeapFlags*)&forMarshaling->flags, sizeof(VkMemoryHeapFlags));
+}
+
+void unmarshal_VkMemoryHeap(
+ VulkanStream* vkStream,
+ VkMemoryHeap* forUnmarshaling)
+{
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+ vkStream->read((VkMemoryHeapFlags*)&forUnmarshaling->flags, sizeof(VkMemoryHeapFlags));
+}
+
+void marshal_VkPhysicalDeviceMemoryProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMemoryProperties* forMarshaling)
+{
+ 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));
+ }
+ 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));
+ }
+}
+
+void unmarshal_VkPhysicalDeviceMemoryProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMemoryProperties* forUnmarshaling)
+{
+ 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));
+ }
+ 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));
+ }
+}
+
+void marshal_VkDeviceQueueCreateInfo(
+ VulkanStream* vkStream,
+ const VkDeviceQueueCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((const float*)forMarshaling->pQueuePriorities, forMarshaling->queueCount * sizeof(const float));
+}
+
+void unmarshal_VkDeviceQueueCreateInfo(
+ VulkanStream* vkStream,
+ VkDeviceQueueCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->alloc((void**)&forUnmarshaling->pQueuePriorities, forUnmarshaling->queueCount * sizeof(const float));
+ vkStream->read((float*)forUnmarshaling->pQueuePriorities, forUnmarshaling->queueCount * sizeof(const float));
+}
+
+void marshal_VkDeviceCreateInfo(
+ VulkanStream* vkStream,
+ const VkDeviceCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDeviceCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->queueCreateInfoCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueCreateInfoCount; ++i)
+ {
+ marshal_VkDeviceQueueCreateInfo(vkStream, (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
+ saveStringArray(vkStream, forMarshaling->ppEnabledLayerNames, forMarshaling->enabledLayerCount);
+ vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
+ saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames, forMarshaling->enabledExtensionCount);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_16 = (uint64_t)(uintptr_t)forMarshaling->pEnabledFeatures;
+ vkStream->putBe64(cgen_var_16);
+ if (forMarshaling->pEnabledFeatures)
+ {
+ marshal_VkPhysicalDeviceFeatures(vkStream, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures));
+ }
+}
+
+void unmarshal_VkDeviceCreateInfo(
+ VulkanStream* vkStream,
+ VkDeviceCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDeviceCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->queueCreateInfoCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pQueueCreateInfos, forUnmarshaling->queueCreateInfoCount * sizeof(const VkDeviceQueueCreateInfo));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueCreateInfoCount; ++i)
+ {
+ unmarshal_VkDeviceQueueCreateInfo(vkStream, (VkDeviceQueueCreateInfo*)(forUnmarshaling->pQueueCreateInfos + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
+ vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledLayerNames);
+ vkStream->read((uint32_t*)&forUnmarshaling->enabledExtensionCount, sizeof(uint32_t));
+ vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledExtensionNames);
+ // WARNING PTR CHECK
+ forUnmarshaling->pEnabledFeatures = (const VkPhysicalDeviceFeatures*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pEnabledFeatures)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pEnabledFeatures, sizeof(const VkPhysicalDeviceFeatures));
+ unmarshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(forUnmarshaling->pEnabledFeatures));
+ }
+}
+
+void marshal_VkExtensionProperties(
+ VulkanStream* vkStream,
+ const VkExtensionProperties* forMarshaling)
+{
+ vkStream->write((char*)forMarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+ vkStream->write((uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
+}
+
+void unmarshal_VkExtensionProperties(
+ VulkanStream* vkStream,
+ VkExtensionProperties* forUnmarshaling)
+{
+ vkStream->read((char*)forUnmarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+ vkStream->read((uint32_t*)&forUnmarshaling->specVersion, sizeof(uint32_t));
+}
+
+void marshal_VkLayerProperties(
+ VulkanStream* vkStream,
+ const VkLayerProperties* forMarshaling)
+{
+ 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));
+ vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+}
+
+void unmarshal_VkLayerProperties(
+ VulkanStream* vkStream,
+ VkLayerProperties* forUnmarshaling)
+{
+ 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));
+ vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+}
+
+void marshal_VkSubmitInfo(
+ VulkanStream* vkStream,
+ const VkSubmitInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
+ if (forMarshaling->waitSemaphoreCount)
+ {
+ uint64_t* cgen_var_18;
+ vkStream->alloc((void**)&cgen_var_18, forMarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_18, forMarshaling->waitSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_18, forMarshaling->waitSemaphoreCount * 8);
+ }
+ vkStream->write((const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask, forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+ vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
+ if (forMarshaling->commandBufferCount)
+ {
+ uint64_t* cgen_var_19;
+ vkStream->alloc((void**)&cgen_var_19, forMarshaling->commandBufferCount * 8);
+ vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(forMarshaling->pCommandBuffers, cgen_var_19, forMarshaling->commandBufferCount);
+ vkStream->write((uint64_t*)cgen_var_19, forMarshaling->commandBufferCount * 8);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
+ if (forMarshaling->signalSemaphoreCount)
+ {
+ uint64_t* cgen_var_20;
+ vkStream->alloc((void**)&cgen_var_20, forMarshaling->signalSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_20, forMarshaling->signalSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_20, forMarshaling->signalSemaphoreCount * 8);
+ }
+}
+
+void unmarshal_VkSubmitInfo(
+ VulkanStream* vkStream,
+ VkSubmitInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
+ if (forUnmarshaling->waitSemaphoreCount)
+ {
+ uint64_t* cgen_var_21;
+ vkStream->alloc((void**)&cgen_var_21, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_21, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_21, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ }
+ vkStream->alloc((void**)&forUnmarshaling->pWaitDstStageMask, forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)forUnmarshaling->pWaitDstStageMask, forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pCommandBuffers, forUnmarshaling->commandBufferCount * sizeof(const VkCommandBuffer));
+ if (forUnmarshaling->commandBufferCount)
+ {
+ uint64_t* cgen_var_22;
+ vkStream->alloc((void**)&cgen_var_22, forUnmarshaling->commandBufferCount * 8);
+ vkStream->read((uint64_t*)cgen_var_22, forUnmarshaling->commandBufferCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_22, (VkCommandBuffer*)forUnmarshaling->pCommandBuffers, forUnmarshaling->commandBufferCount);
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount * sizeof(const VkSemaphore));
+ if (forUnmarshaling->signalSemaphoreCount)
+ {
+ uint64_t* cgen_var_23;
+ vkStream->alloc((void**)&cgen_var_23, forUnmarshaling->signalSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_23, forUnmarshaling->signalSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_23, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
+ }
+}
+
+void marshal_VkMemoryAllocateInfo(
+ VulkanStream* vkStream,
+ const VkMemoryAllocateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
+ vkStream->write((uint32_t*)&forMarshaling->memoryTypeIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryAllocateInfo(
+ VulkanStream* vkStream,
+ VkMemoryAllocateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeIndex, sizeof(uint32_t));
+}
+
+void marshal_VkMappedMemoryRange(
+ VulkanStream* vkStream,
+ const VkMappedMemoryRange* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_24;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_24, 1);
+ vkStream->write((uint64_t*)&cgen_var_24, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkMappedMemoryRange(
+ VulkanStream* vkStream,
+ VkMappedMemoryRange* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_25;
+ vkStream->read((uint64_t*)&cgen_var_25, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_25, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkMemoryRequirements(
+ VulkanStream* vkStream,
+ const VkMemoryRequirements* forMarshaling)
+{
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->alignment, sizeof(VkDeviceSize));
+ vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryRequirements(
+ VulkanStream* vkStream,
+ VkMemoryRequirements* forUnmarshaling)
+{
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->alignment, sizeof(VkDeviceSize));
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkSparseImageFormatProperties(
+ VulkanStream* vkStream,
+ const VkSparseImageFormatProperties* forMarshaling)
+{
+ vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+ marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->imageGranularity));
+ vkStream->write((VkSparseImageFormatFlags*)&forMarshaling->flags, sizeof(VkSparseImageFormatFlags));
+}
+
+void unmarshal_VkSparseImageFormatProperties(
+ VulkanStream* vkStream,
+ VkSparseImageFormatProperties* forUnmarshaling)
+{
+ vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+ unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->imageGranularity));
+ vkStream->read((VkSparseImageFormatFlags*)&forUnmarshaling->flags, sizeof(VkSparseImageFormatFlags));
+}
+
+void marshal_VkSparseImageMemoryRequirements(
+ VulkanStream* vkStream,
+ const VkSparseImageMemoryRequirements* forMarshaling)
+{
+ marshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties));
+ vkStream->write((uint32_t*)&forMarshaling->imageMipTailFirstLod, sizeof(uint32_t));
+ vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailSize, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailStride, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkSparseImageMemoryRequirements(
+ VulkanStream* vkStream,
+ VkSparseImageMemoryRequirements* forUnmarshaling)
+{
+ unmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forUnmarshaling->formatProperties));
+ vkStream->read((uint32_t*)&forUnmarshaling->imageMipTailFirstLod, sizeof(uint32_t));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailSize, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailStride, sizeof(VkDeviceSize));
+}
+
+void marshal_VkSparseMemoryBind(
+ VulkanStream* vkStream,
+ const VkSparseMemoryBind* forMarshaling)
+{
+ vkStream->write((VkDeviceSize*)&forMarshaling->resourceOffset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ uint64_t cgen_var_26;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_26, 1);
+ vkStream->write((uint64_t*)&cgen_var_26, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
+ vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+}
+
+void unmarshal_VkSparseMemoryBind(
+ VulkanStream* vkStream,
+ VkSparseMemoryBind* forUnmarshaling)
+{
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->resourceOffset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+ uint64_t cgen_var_27;
+ vkStream->read((uint64_t*)&cgen_var_27, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_27, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
+ vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+}
+
+void marshal_VkSparseBufferMemoryBindInfo(
+ VulkanStream* vkStream,
+ const VkSparseBufferMemoryBindInfo* forMarshaling)
+{
+ uint64_t cgen_var_28;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_28, 1);
+ vkStream->write((uint64_t*)&cgen_var_28, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
+ {
+ marshal_VkSparseMemoryBind(vkStream, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
+ }
+}
+
+void unmarshal_VkSparseBufferMemoryBindInfo(
+ VulkanStream* vkStream,
+ VkSparseBufferMemoryBindInfo* forUnmarshaling)
+{
+ uint64_t cgen_var_29;
+ vkStream->read((uint64_t*)&cgen_var_29, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_29, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pBinds, forUnmarshaling->bindCount * sizeof(const VkSparseMemoryBind));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
+ {
+ unmarshal_VkSparseMemoryBind(vkStream, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
+ }
+}
+
+void marshal_VkSparseImageOpaqueMemoryBindInfo(
+ VulkanStream* vkStream,
+ const VkSparseImageOpaqueMemoryBindInfo* forMarshaling)
+{
+ uint64_t cgen_var_30;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_30, 1);
+ vkStream->write((uint64_t*)&cgen_var_30, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
+ {
+ marshal_VkSparseMemoryBind(vkStream, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
+ }
+}
+
+void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
+ VulkanStream* vkStream,
+ VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling)
+{
+ uint64_t cgen_var_31;
+ vkStream->read((uint64_t*)&cgen_var_31, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_31, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pBinds, forUnmarshaling->bindCount * sizeof(const VkSparseMemoryBind));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
+ {
+ unmarshal_VkSparseMemoryBind(vkStream, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
+ }
+}
+
+void marshal_VkImageSubresource(
+ VulkanStream* vkStream,
+ const VkImageSubresource* forMarshaling)
+{
+ vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+ vkStream->write((uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->arrayLayer, sizeof(uint32_t));
+}
+
+void unmarshal_VkImageSubresource(
+ VulkanStream* vkStream,
+ VkImageSubresource* forUnmarshaling)
+{
+ vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->mipLevel, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->arrayLayer, sizeof(uint32_t));
+}
+
+void marshal_VkOffset3D(
+ VulkanStream* vkStream,
+ const VkOffset3D* forMarshaling)
+{
+ vkStream->write((int32_t*)&forMarshaling->x, sizeof(int32_t));
+ vkStream->write((int32_t*)&forMarshaling->y, sizeof(int32_t));
+ vkStream->write((int32_t*)&forMarshaling->z, sizeof(int32_t));
+}
+
+void unmarshal_VkOffset3D(
+ VulkanStream* vkStream,
+ VkOffset3D* forUnmarshaling)
+{
+ vkStream->read((int32_t*)&forUnmarshaling->x, sizeof(int32_t));
+ vkStream->read((int32_t*)&forUnmarshaling->y, sizeof(int32_t));
+ vkStream->read((int32_t*)&forUnmarshaling->z, sizeof(int32_t));
+}
+
+void marshal_VkSparseImageMemoryBind(
+ VulkanStream* vkStream,
+ const VkSparseImageMemoryBind* forMarshaling)
+{
+ marshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forMarshaling->subresource));
+ marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->offset));
+ marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
+ uint64_t cgen_var_32;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_32, 1);
+ vkStream->write((uint64_t*)&cgen_var_32, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
+ vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+}
+
+void unmarshal_VkSparseImageMemoryBind(
+ VulkanStream* vkStream,
+ VkSparseImageMemoryBind* forUnmarshaling)
+{
+ unmarshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forUnmarshaling->subresource));
+ unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->offset));
+ unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
+ uint64_t cgen_var_33;
+ vkStream->read((uint64_t*)&cgen_var_33, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_33, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
+ vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+}
+
+void marshal_VkSparseImageMemoryBindInfo(
+ VulkanStream* vkStream,
+ const VkSparseImageMemoryBindInfo* forMarshaling)
+{
+ uint64_t cgen_var_34;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_34, 1);
+ vkStream->write((uint64_t*)&cgen_var_34, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
+ {
+ marshal_VkSparseImageMemoryBind(vkStream, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i));
+ }
+}
+
+void unmarshal_VkSparseImageMemoryBindInfo(
+ VulkanStream* vkStream,
+ VkSparseImageMemoryBindInfo* forUnmarshaling)
+{
+ uint64_t cgen_var_35;
+ vkStream->read((uint64_t*)&cgen_var_35, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_35, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pBinds, forUnmarshaling->bindCount * sizeof(const VkSparseImageMemoryBind));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
+ {
+ unmarshal_VkSparseImageMemoryBind(vkStream, (VkSparseImageMemoryBind*)(forUnmarshaling->pBinds + i));
+ }
+}
+
+void marshal_VkBindSparseInfo(
+ VulkanStream* vkStream,
+ const VkBindSparseInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
+ if (forMarshaling->waitSemaphoreCount)
+ {
+ uint64_t* cgen_var_36;
+ vkStream->alloc((void**)&cgen_var_36, forMarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_36, forMarshaling->waitSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_36, forMarshaling->waitSemaphoreCount * 8);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->bufferBindCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i)
+ {
+ marshal_VkSparseBufferMemoryBindInfo(vkStream, (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->imageOpaqueBindCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i)
+ {
+ marshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->imageBindCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i)
+ {
+ marshal_VkSparseImageMemoryBindInfo(vkStream, (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
+ if (forMarshaling->signalSemaphoreCount)
+ {
+ uint64_t* cgen_var_37;
+ vkStream->alloc((void**)&cgen_var_37, forMarshaling->signalSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_37, forMarshaling->signalSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_37, forMarshaling->signalSemaphoreCount * 8);
+ }
+}
+
+void unmarshal_VkBindSparseInfo(
+ VulkanStream* vkStream,
+ VkBindSparseInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
+ if (forUnmarshaling->waitSemaphoreCount)
+ {
+ uint64_t* cgen_var_38;
+ vkStream->alloc((void**)&cgen_var_38, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_38, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_38, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->bufferBindCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pBufferBinds, forUnmarshaling->bufferBindCount * sizeof(const VkSparseBufferMemoryBindInfo));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferBindCount; ++i)
+ {
+ unmarshal_VkSparseBufferMemoryBindInfo(vkStream, (VkSparseBufferMemoryBindInfo*)(forUnmarshaling->pBufferBinds + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->imageOpaqueBindCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pImageOpaqueBinds, forUnmarshaling->imageOpaqueBindCount * sizeof(const VkSparseImageOpaqueMemoryBindInfo));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageOpaqueBindCount; ++i)
+ {
+ unmarshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, (VkSparseImageOpaqueMemoryBindInfo*)(forUnmarshaling->pImageOpaqueBinds + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->imageBindCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pImageBinds, forUnmarshaling->imageBindCount * sizeof(const VkSparseImageMemoryBindInfo));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageBindCount; ++i)
+ {
+ unmarshal_VkSparseImageMemoryBindInfo(vkStream, (VkSparseImageMemoryBindInfo*)(forUnmarshaling->pImageBinds + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount * sizeof(const VkSemaphore));
+ if (forUnmarshaling->signalSemaphoreCount)
+ {
+ uint64_t* cgen_var_39;
+ vkStream->alloc((void**)&cgen_var_39, forUnmarshaling->signalSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_39, forUnmarshaling->signalSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_39, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
+ }
+}
+
+void marshal_VkFenceCreateInfo(
+ VulkanStream* vkStream,
+ const VkFenceCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkFenceCreateFlags*)&forMarshaling->flags, sizeof(VkFenceCreateFlags));
+}
+
+void unmarshal_VkFenceCreateInfo(
+ VulkanStream* vkStream,
+ VkFenceCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkFenceCreateFlags*)&forUnmarshaling->flags, sizeof(VkFenceCreateFlags));
+}
+
+void marshal_VkSemaphoreCreateInfo(
+ VulkanStream* vkStream,
+ const VkSemaphoreCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkSemaphoreCreateFlags*)&forMarshaling->flags, sizeof(VkSemaphoreCreateFlags));
+}
+
+void unmarshal_VkSemaphoreCreateInfo(
+ VulkanStream* vkStream,
+ VkSemaphoreCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkSemaphoreCreateFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreCreateFlags));
+}
+
+void marshal_VkEventCreateInfo(
+ VulkanStream* vkStream,
+ const VkEventCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkEventCreateFlags*)&forMarshaling->flags, sizeof(VkEventCreateFlags));
+}
+
+void unmarshal_VkEventCreateInfo(
+ VulkanStream* vkStream,
+ VkEventCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkEventCreateFlags*)&forUnmarshaling->flags, sizeof(VkEventCreateFlags));
+}
+
+void marshal_VkQueryPoolCreateInfo(
+ VulkanStream* vkStream,
+ const VkQueryPoolCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkQueryPoolCreateFlags*)&forMarshaling->flags, sizeof(VkQueryPoolCreateFlags));
+ vkStream->write((VkQueryType*)&forMarshaling->queryType, sizeof(VkQueryType));
+ vkStream->write((uint32_t*)&forMarshaling->queryCount, sizeof(uint32_t));
+ vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+}
+
+void unmarshal_VkQueryPoolCreateInfo(
+ VulkanStream* vkStream,
+ VkQueryPoolCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+}
+
+void marshal_VkBufferCreateInfo(
+ VulkanStream* vkStream,
+ const VkBufferCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
+ vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
+ vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_40 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+ vkStream->putBe64(cgen_var_40);
+ if (forMarshaling->pQueueFamilyIndices)
+ {
+ vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ }
+}
+
+void unmarshal_VkBufferCreateInfo(
+ VulkanStream* vkStream,
+ VkBufferCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferCreateFlags));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+ vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
+ vkStream->read((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
+ vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pQueueFamilyIndices)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ }
+}
+
+void marshal_VkBufferViewCreateInfo(
+ VulkanStream* vkStream,
+ const VkBufferViewCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBufferViewCreateFlags*)&forMarshaling->flags, sizeof(VkBufferViewCreateFlags));
+ uint64_t cgen_var_42;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_42, 1);
+ vkStream->write((uint64_t*)&cgen_var_42, 1 * 8);
+ vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+ vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBufferViewCreateInfo(
+ VulkanStream* vkStream,
+ VkBufferViewCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBufferViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferViewCreateFlags));
+ uint64_t cgen_var_43;
+ vkStream->read((uint64_t*)&cgen_var_43, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_43, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
+}
+
+void marshal_VkImageCreateInfo(
+ VulkanStream* vkStream,
+ const VkImageCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ 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));
+ vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
+ vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
+ vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_44 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+ vkStream->putBe64(cgen_var_44);
+ if (forMarshaling->pQueueFamilyIndices)
+ {
+ vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ }
+ vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkImageCreateInfo(
+ VulkanStream* vkStream,
+ VkImageCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((uint32_t*)&forUnmarshaling->mipLevels, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->arrayLayers, sizeof(uint32_t));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
+ vkStream->read((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
+ vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pQueueFamilyIndices)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ }
+ vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
+}
+
+void marshal_VkSubresourceLayout(
+ VulkanStream* vkStream,
+ const VkSubresourceLayout* forMarshaling)
+{
+ vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->rowPitch, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->arrayPitch, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->depthPitch, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkSubresourceLayout(
+ VulkanStream* vkStream,
+ VkSubresourceLayout* forUnmarshaling)
+{
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->rowPitch, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->arrayPitch, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->depthPitch, sizeof(VkDeviceSize));
+}
+
+void marshal_VkComponentMapping(
+ VulkanStream* vkStream,
+ const VkComponentMapping* forMarshaling)
+{
+ vkStream->write((VkComponentSwizzle*)&forMarshaling->r, sizeof(VkComponentSwizzle));
+ vkStream->write((VkComponentSwizzle*)&forMarshaling->g, sizeof(VkComponentSwizzle));
+ vkStream->write((VkComponentSwizzle*)&forMarshaling->b, sizeof(VkComponentSwizzle));
+ vkStream->write((VkComponentSwizzle*)&forMarshaling->a, sizeof(VkComponentSwizzle));
+}
+
+void unmarshal_VkComponentMapping(
+ VulkanStream* vkStream,
+ VkComponentMapping* forUnmarshaling)
+{
+ vkStream->read((VkComponentSwizzle*)&forUnmarshaling->r, sizeof(VkComponentSwizzle));
+ vkStream->read((VkComponentSwizzle*)&forUnmarshaling->g, sizeof(VkComponentSwizzle));
+ vkStream->read((VkComponentSwizzle*)&forUnmarshaling->b, sizeof(VkComponentSwizzle));
+ vkStream->read((VkComponentSwizzle*)&forUnmarshaling->a, sizeof(VkComponentSwizzle));
+}
+
+void marshal_VkImageSubresourceRange(
+ VulkanStream* vkStream,
+ const VkImageSubresourceRange* forMarshaling)
+{
+ 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));
+ vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkImageSubresourceRange(
+ VulkanStream* vkStream,
+ VkImageSubresourceRange* forUnmarshaling)
+{
+ 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));
+ vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
+}
+
+void marshal_VkImageViewCreateInfo(
+ VulkanStream* vkStream,
+ const VkImageViewCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkImageViewCreateFlags*)&forMarshaling->flags, sizeof(VkImageViewCreateFlags));
+ uint64_t cgen_var_46;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_46, 1);
+ vkStream->write((uint64_t*)&cgen_var_46, 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));
+}
+
+void unmarshal_VkImageViewCreateInfo(
+ VulkanStream* vkStream,
+ VkImageViewCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkImageViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageViewCreateFlags));
+ uint64_t cgen_var_47;
+ vkStream->read((uint64_t*)&cgen_var_47, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_47, (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));
+}
+
+void marshal_VkShaderModuleCreateInfo(
+ VulkanStream* vkStream,
+ const VkShaderModuleCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkShaderModuleCreateFlags*)&forMarshaling->flags, sizeof(VkShaderModuleCreateFlags));
+ uint64_t cgen_var_48 = (uint64_t)forMarshaling->codeSize;
+ vkStream->putBe64(cgen_var_48);
+ vkStream->write((const uint32_t*)forMarshaling->pCode, (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
+}
+
+void unmarshal_VkShaderModuleCreateInfo(
+ VulkanStream* vkStream,
+ VkShaderModuleCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkShaderModuleCreateFlags*)&forUnmarshaling->flags, sizeof(VkShaderModuleCreateFlags));
+ forUnmarshaling->codeSize = (size_t)vkStream->getBe64();
+ vkStream->alloc((void**)&forUnmarshaling->pCode, (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCode, (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
+}
+
+void marshal_VkPipelineCacheCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineCacheCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineCacheCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
+ uint64_t cgen_var_50 = (uint64_t)forMarshaling->initialDataSize;
+ vkStream->putBe64(cgen_var_50);
+ vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkPipelineCacheCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineCacheCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineCacheCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
+ forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
+ vkStream->alloc((void**)&forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+}
+
+void marshal_VkSpecializationMapEntry(
+ VulkanStream* vkStream,
+ const VkSpecializationMapEntry* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->constantID, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
+ uint64_t cgen_var_52 = (uint64_t)forMarshaling->size;
+ vkStream->putBe64(cgen_var_52);
+}
+
+void unmarshal_VkSpecializationMapEntry(
+ VulkanStream* vkStream,
+ VkSpecializationMapEntry* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->constantID, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
+ forUnmarshaling->size = (size_t)vkStream->getBe64();
+}
+
+void marshal_VkSpecializationInfo(
+ VulkanStream* vkStream,
+ const VkSpecializationInfo* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->mapEntryCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->mapEntryCount; ++i)
+ {
+ marshal_VkSpecializationMapEntry(vkStream, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i));
+ }
+ uint64_t cgen_var_54 = (uint64_t)forMarshaling->dataSize;
+ vkStream->putBe64(cgen_var_54);
+ vkStream->write((const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkSpecializationInfo(
+ VulkanStream* vkStream,
+ VkSpecializationInfo* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->mapEntryCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pMapEntries, forUnmarshaling->mapEntryCount * sizeof(const VkSpecializationMapEntry));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mapEntryCount; ++i)
+ {
+ unmarshal_VkSpecializationMapEntry(vkStream, (VkSpecializationMapEntry*)(forUnmarshaling->pMapEntries + i));
+ }
+ forUnmarshaling->dataSize = (size_t)vkStream->getBe64();
+ vkStream->alloc((void**)&forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(const uint8_t));
+}
+
+void marshal_VkPipelineShaderStageCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineShaderStageCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineShaderStageCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
+ vkStream->write((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
+ uint64_t cgen_var_56;
+ vkStream->handleMapping()->mapHandles_VkShaderModule_u64(&forMarshaling->module, &cgen_var_56, 1);
+ vkStream->write((uint64_t*)&cgen_var_56, 1 * 8);
+ vkStream->putString(forMarshaling->pName);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_57 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
+ vkStream->putBe64(cgen_var_57);
+ if (forMarshaling->pSpecializationInfo)
+ {
+ marshal_VkSpecializationInfo(vkStream, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
+ }
+}
+
+void unmarshal_VkPipelineShaderStageCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineShaderStageCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineShaderStageCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
+ vkStream->read((VkShaderStageFlagBits*)&forUnmarshaling->stage, sizeof(VkShaderStageFlagBits));
+ uint64_t cgen_var_58;
+ vkStream->read((uint64_t*)&cgen_var_58, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_58, (VkShaderModule*)&forUnmarshaling->module, 1);
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
+ // WARNING PTR CHECK
+ forUnmarshaling->pSpecializationInfo = (const VkSpecializationInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pSpecializationInfo)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pSpecializationInfo, sizeof(const VkSpecializationInfo));
+ unmarshal_VkSpecializationInfo(vkStream, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
+ }
+}
+
+void marshal_VkVertexInputBindingDescription(
+ VulkanStream* vkStream,
+ const VkVertexInputBindingDescription* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
+ vkStream->write((VkVertexInputRate*)&forMarshaling->inputRate, sizeof(VkVertexInputRate));
+}
+
+void unmarshal_VkVertexInputBindingDescription(
+ VulkanStream* vkStream,
+ VkVertexInputBindingDescription* forUnmarshaling)
+{
+ 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));
+}
+
+void marshal_VkVertexInputAttributeDescription(
+ VulkanStream* vkStream,
+ const VkVertexInputAttributeDescription* forMarshaling)
+{
+ 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));
+ vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
+}
+
+void unmarshal_VkVertexInputAttributeDescription(
+ VulkanStream* vkStream,
+ VkVertexInputAttributeDescription* forUnmarshaling)
+{
+ 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));
+ vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineVertexInputStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineVertexInputStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineVertexInputStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineVertexInputStateCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i)
+ {
+ marshal_VkVertexInputBindingDescription(vkStream, (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i)
+ {
+ marshal_VkVertexInputAttributeDescription(vkStream, (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions + i));
+ }
+}
+
+void unmarshal_VkPipelineVertexInputStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineVertexInputStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineVertexInputStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineVertexInputStateCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pVertexBindingDescriptions, forUnmarshaling->vertexBindingDescriptionCount * sizeof(const VkVertexInputBindingDescription));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDescriptionCount; ++i)
+ {
+ unmarshal_VkVertexInputBindingDescription(vkStream, (VkVertexInputBindingDescription*)(forUnmarshaling->pVertexBindingDescriptions + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pVertexAttributeDescriptions, forUnmarshaling->vertexAttributeDescriptionCount * sizeof(const VkVertexInputAttributeDescription));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexAttributeDescriptionCount; ++i)
+ {
+ unmarshal_VkVertexInputAttributeDescription(vkStream, (VkVertexInputAttributeDescription*)(forUnmarshaling->pVertexAttributeDescriptions + i));
+ }
+}
+
+void marshal_VkPipelineInputAssemblyStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineInputAssemblyStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineInputAssemblyStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineInputAssemblyStateCreateFlags));
+ vkStream->write((VkPrimitiveTopology*)&forMarshaling->topology, sizeof(VkPrimitiveTopology));
+ vkStream->write((VkBool32*)&forMarshaling->primitiveRestartEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineInputAssemblyStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineInputAssemblyStateCreateFlags));
+ vkStream->read((VkPrimitiveTopology*)&forUnmarshaling->topology, sizeof(VkPrimitiveTopology));
+ vkStream->read((VkBool32*)&forUnmarshaling->primitiveRestartEnable, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineTessellationStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineTessellationStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
+}
+
+void unmarshal_VkPipelineTessellationStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineTessellationStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineTessellationStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->patchControlPoints, sizeof(uint32_t));
+}
+
+void marshal_VkViewport(
+ VulkanStream* vkStream,
+ const VkViewport* forMarshaling)
+{
+ vkStream->write((float*)&forMarshaling->x, sizeof(float));
+ vkStream->write((float*)&forMarshaling->y, sizeof(float));
+ vkStream->write((float*)&forMarshaling->width, sizeof(float));
+ vkStream->write((float*)&forMarshaling->height, sizeof(float));
+ vkStream->write((float*)&forMarshaling->minDepth, sizeof(float));
+ vkStream->write((float*)&forMarshaling->maxDepth, sizeof(float));
+}
+
+void unmarshal_VkViewport(
+ VulkanStream* vkStream,
+ VkViewport* forUnmarshaling)
+{
+ vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->width, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->height, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->minDepth, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->maxDepth, sizeof(float));
+}
+
+void marshal_VkOffset2D(
+ VulkanStream* vkStream,
+ const VkOffset2D* forMarshaling)
+{
+ vkStream->write((int32_t*)&forMarshaling->x, sizeof(int32_t));
+ vkStream->write((int32_t*)&forMarshaling->y, sizeof(int32_t));
+}
+
+void unmarshal_VkOffset2D(
+ VulkanStream* vkStream,
+ VkOffset2D* forUnmarshaling)
+{
+ vkStream->read((int32_t*)&forUnmarshaling->x, sizeof(int32_t));
+ vkStream->read((int32_t*)&forUnmarshaling->y, sizeof(int32_t));
+}
+
+void marshal_VkExtent2D(
+ VulkanStream* vkStream,
+ const VkExtent2D* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+}
+
+void unmarshal_VkExtent2D(
+ VulkanStream* vkStream,
+ VkExtent2D* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+}
+
+void marshal_VkRect2D(
+ VulkanStream* vkStream,
+ const VkRect2D* forMarshaling)
+{
+ marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->offset));
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->extent));
+}
+
+void unmarshal_VkRect2D(
+ VulkanStream* vkStream,
+ VkRect2D* forUnmarshaling)
+{
+ unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->offset));
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->extent));
+}
+
+void marshal_VkPipelineViewportStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineViewportStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineViewportStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineViewportStateCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_60 = (uint64_t)(uintptr_t)forMarshaling->pViewports;
+ vkStream->putBe64(cgen_var_60);
+ if (forMarshaling->pViewports)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
+ {
+ marshal_VkViewport(vkStream, (const VkViewport*)(forMarshaling->pViewports + i));
+ }
+ }
+ vkStream->write((uint32_t*)&forMarshaling->scissorCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_61 = (uint64_t)(uintptr_t)forMarshaling->pScissors;
+ vkStream->putBe64(cgen_var_61);
+ if (forMarshaling->pScissors)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i)
+ {
+ marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pScissors + i));
+ }
+ }
+}
+
+void unmarshal_VkPipelineViewportStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineViewportStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineViewportStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineViewportStateCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pViewports = (const VkViewport*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pViewports)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pViewports, forUnmarshaling->viewportCount * sizeof(const VkViewport));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
+ {
+ unmarshal_VkViewport(vkStream, (VkViewport*)(forUnmarshaling->pViewports + i));
+ }
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->scissorCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pScissors = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pScissors)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pScissors, forUnmarshaling->scissorCount * sizeof(const VkRect2D));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->scissorCount; ++i)
+ {
+ unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pScissors + i));
+ }
+ }
+}
+
+void marshal_VkPipelineRasterizationStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineRasterizationStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineRasterizationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineRasterizationStateCreateFlags));
+ vkStream->write((VkBool32*)&forMarshaling->depthClampEnable, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
+ vkStream->write((VkPolygonMode*)&forMarshaling->polygonMode, sizeof(VkPolygonMode));
+ vkStream->write((VkCullModeFlags*)&forMarshaling->cullMode, sizeof(VkCullModeFlags));
+ vkStream->write((VkFrontFace*)&forMarshaling->frontFace, sizeof(VkFrontFace));
+ vkStream->write((VkBool32*)&forMarshaling->depthBiasEnable, sizeof(VkBool32));
+ vkStream->write((float*)&forMarshaling->depthBiasConstantFactor, sizeof(float));
+ vkStream->write((float*)&forMarshaling->depthBiasClamp, sizeof(float));
+ vkStream->write((float*)&forMarshaling->depthBiasSlopeFactor, sizeof(float));
+ vkStream->write((float*)&forMarshaling->lineWidth, sizeof(float));
+}
+
+void unmarshal_VkPipelineRasterizationStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineRasterizationStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineRasterizationStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineRasterizationStateCreateFlags));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthClampEnable, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
+ vkStream->read((VkPolygonMode*)&forUnmarshaling->polygonMode, sizeof(VkPolygonMode));
+ vkStream->read((VkCullModeFlags*)&forUnmarshaling->cullMode, sizeof(VkCullModeFlags));
+ vkStream->read((VkFrontFace*)&forUnmarshaling->frontFace, sizeof(VkFrontFace));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthBiasEnable, sizeof(VkBool32));
+ vkStream->read((float*)&forUnmarshaling->depthBiasConstantFactor, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->depthBiasClamp, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->depthBiasSlopeFactor, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->lineWidth, sizeof(float));
+}
+
+void marshal_VkPipelineMultisampleStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineMultisampleStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineMultisampleStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineMultisampleStateCreateFlags));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkBool32*)&forMarshaling->sampleShadingEnable, sizeof(VkBool32));
+ vkStream->write((float*)&forMarshaling->minSampleShading, sizeof(float));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_64 = (uint64_t)(uintptr_t)forMarshaling->pSampleMask;
+ vkStream->putBe64(cgen_var_64);
+ if (forMarshaling->pSampleMask)
+ {
+ vkStream->write((const VkSampleMask*)forMarshaling->pSampleMask, (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+ }
+ vkStream->write((VkBool32*)&forMarshaling->alphaToCoverageEnable, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->alphaToOneEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPipelineMultisampleStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineMultisampleStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineMultisampleStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineMultisampleStateCreateFlags));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkBool32*)&forUnmarshaling->sampleShadingEnable, sizeof(VkBool32));
+ vkStream->read((float*)&forUnmarshaling->minSampleShading, sizeof(float));
+ // WARNING PTR CHECK
+ forUnmarshaling->pSampleMask = (const VkSampleMask*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pSampleMask)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pSampleMask, (((forUnmarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+ vkStream->read((VkSampleMask*)forUnmarshaling->pSampleMask, (((forUnmarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->alphaToCoverageEnable, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->alphaToOneEnable, sizeof(VkBool32));
+}
+
+void marshal_VkStencilOpState(
+ VulkanStream* vkStream,
+ const VkStencilOpState* forMarshaling)
+{
+ vkStream->write((VkStencilOp*)&forMarshaling->failOp, sizeof(VkStencilOp));
+ vkStream->write((VkStencilOp*)&forMarshaling->passOp, sizeof(VkStencilOp));
+ vkStream->write((VkStencilOp*)&forMarshaling->depthFailOp, sizeof(VkStencilOp));
+ vkStream->write((VkCompareOp*)&forMarshaling->compareOp, sizeof(VkCompareOp));
+ vkStream->write((uint32_t*)&forMarshaling->compareMask, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->writeMask, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->reference, sizeof(uint32_t));
+}
+
+void unmarshal_VkStencilOpState(
+ VulkanStream* vkStream,
+ VkStencilOpState* forUnmarshaling)
+{
+ vkStream->read((VkStencilOp*)&forUnmarshaling->failOp, sizeof(VkStencilOp));
+ vkStream->read((VkStencilOp*)&forUnmarshaling->passOp, sizeof(VkStencilOp));
+ vkStream->read((VkStencilOp*)&forUnmarshaling->depthFailOp, sizeof(VkStencilOp));
+ vkStream->read((VkCompareOp*)&forUnmarshaling->compareOp, sizeof(VkCompareOp));
+ vkStream->read((uint32_t*)&forUnmarshaling->compareMask, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->writeMask, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->reference, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineDepthStencilStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineDepthStencilStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((float*)&forMarshaling->minDepthBounds, sizeof(float));
+ vkStream->write((float*)&forMarshaling->maxDepthBounds, sizeof(float));
+}
+
+void unmarshal_VkPipelineDepthStencilStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineDepthStencilStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((float*)&forUnmarshaling->minDepthBounds, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->maxDepthBounds, sizeof(float));
+}
+
+void marshal_VkPipelineColorBlendAttachmentState(
+ VulkanStream* vkStream,
+ const VkPipelineColorBlendAttachmentState* forMarshaling)
+{
+ vkStream->write((VkBool32*)&forMarshaling->blendEnable, sizeof(VkBool32));
+ vkStream->write((VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
+ vkStream->write((VkBlendFactor*)&forMarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
+ vkStream->write((VkBlendOp*)&forMarshaling->colorBlendOp, sizeof(VkBlendOp));
+ vkStream->write((VkBlendFactor*)&forMarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
+ vkStream->write((VkBlendFactor*)&forMarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
+ vkStream->write((VkBlendOp*)&forMarshaling->alphaBlendOp, sizeof(VkBlendOp));
+ vkStream->write((VkColorComponentFlags*)&forMarshaling->colorWriteMask, sizeof(VkColorComponentFlags));
+}
+
+void unmarshal_VkPipelineColorBlendAttachmentState(
+ VulkanStream* vkStream,
+ VkPipelineColorBlendAttachmentState* forUnmarshaling)
+{
+ vkStream->read((VkBool32*)&forUnmarshaling->blendEnable, sizeof(VkBool32));
+ vkStream->read((VkBlendFactor*)&forUnmarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
+ vkStream->read((VkBlendFactor*)&forUnmarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
+ vkStream->read((VkBlendOp*)&forUnmarshaling->colorBlendOp, sizeof(VkBlendOp));
+ vkStream->read((VkBlendFactor*)&forUnmarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
+ vkStream->read((VkBlendFactor*)&forUnmarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
+ vkStream->read((VkBlendOp*)&forUnmarshaling->alphaBlendOp, sizeof(VkBlendOp));
+ vkStream->read((VkColorComponentFlags*)&forUnmarshaling->colorWriteMask, sizeof(VkColorComponentFlags));
+}
+
+void marshal_VkPipelineColorBlendStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineColorBlendStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineColorBlendStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineColorBlendStateCreateFlags));
+ vkStream->write((VkBool32*)&forMarshaling->logicOpEnable, sizeof(VkBool32));
+ vkStream->write((VkLogicOp*)&forMarshaling->logicOp, sizeof(VkLogicOp));
+ vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
+ {
+ marshal_VkPipelineColorBlendAttachmentState(vkStream, (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i));
+ }
+ vkStream->write((float*)forMarshaling->blendConstants, 4 * sizeof(float));
+}
+
+void unmarshal_VkPipelineColorBlendStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineColorBlendStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineColorBlendStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineColorBlendStateCreateFlags));
+ vkStream->read((VkBool32*)&forUnmarshaling->logicOpEnable, sizeof(VkBool32));
+ vkStream->read((VkLogicOp*)&forUnmarshaling->logicOp, sizeof(VkLogicOp));
+ vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount * sizeof(const VkPipelineColorBlendAttachmentState));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
+ {
+ unmarshal_VkPipelineColorBlendAttachmentState(vkStream, (VkPipelineColorBlendAttachmentState*)(forUnmarshaling->pAttachments + i));
+ }
+ vkStream->read((float*)forUnmarshaling->blendConstants, 4 * sizeof(float));
+}
+
+void marshal_VkPipelineDynamicStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineDynamicStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+}
+
+void unmarshal_VkPipelineDynamicStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineDynamicStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineDynamicStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineDynamicStateCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->dynamicStateCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDynamicStates, forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
+ vkStream->read((VkDynamicState*)forUnmarshaling->pDynamicStates, forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
+}
+
+void marshal_VkGraphicsPipelineCreateInfo(
+ VulkanStream* vkStream,
+ const VkGraphicsPipelineCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
+ {
+ marshal_VkPipelineShaderStageCreateInfo(vkStream, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ }
+ marshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
+ marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_66 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
+ vkStream->putBe64(cgen_var_66);
+ if (forMarshaling->pTessellationState)
+ {
+ marshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_67 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
+ vkStream->putBe64(cgen_var_67);
+ if (forMarshaling->pViewportState)
+ {
+ marshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
+ }
+ marshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_68 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
+ vkStream->putBe64(cgen_var_68);
+ if (forMarshaling->pMultisampleState)
+ {
+ marshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_69 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
+ vkStream->putBe64(cgen_var_69);
+ if (forMarshaling->pDepthStencilState)
+ {
+ marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_70 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
+ vkStream->putBe64(cgen_var_70);
+ if (forMarshaling->pColorBlendState)
+ {
+ marshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_71 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
+ vkStream->putBe64(cgen_var_71);
+ if (forMarshaling->pDynamicState)
+ {
+ marshal_VkPipelineDynamicStateCreateInfo(vkStream, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
+ }
+ uint64_t cgen_var_72;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_72, 1);
+ vkStream->write((uint64_t*)&cgen_var_72, 1 * 8);
+ uint64_t cgen_var_73;
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_73, 1);
+ vkStream->write((uint64_t*)&cgen_var_73, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
+ uint64_t cgen_var_74;
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_74, 1);
+ vkStream->write((uint64_t*)&cgen_var_74, 1 * 8);
+ vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void unmarshal_VkGraphicsPipelineCreateInfo(
+ VulkanStream* vkStream,
+ VkGraphicsPipelineCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pStages, forUnmarshaling->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i)
+ {
+ unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ }
+ vkStream->alloc((void**)&forUnmarshaling->pVertexInputState, sizeof(const VkPipelineVertexInputStateCreateInfo));
+ unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
+ vkStream->alloc((void**)&forUnmarshaling->pInputAssemblyState, sizeof(const VkPipelineInputAssemblyStateCreateInfo));
+ unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
+ // WARNING PTR CHECK
+ forUnmarshaling->pTessellationState = (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pTessellationState)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pTessellationState, sizeof(const VkPipelineTessellationStateCreateInfo));
+ unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pViewportState = (const VkPipelineViewportStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pViewportState)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pViewportState, sizeof(const VkPipelineViewportStateCreateInfo));
+ unmarshal_VkPipelineViewportStateCreateInfo(vkStream, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
+ }
+ vkStream->alloc((void**)&forUnmarshaling->pRasterizationState, sizeof(const VkPipelineRasterizationStateCreateInfo));
+ unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
+ // WARNING PTR CHECK
+ forUnmarshaling->pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pMultisampleState)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pMultisampleState, sizeof(const VkPipelineMultisampleStateCreateInfo));
+ unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pDepthStencilState = (const VkPipelineDepthStencilStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDepthStencilState)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pDepthStencilState, sizeof(const VkPipelineDepthStencilStateCreateInfo));
+ unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pColorBlendState = (const VkPipelineColorBlendStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pColorBlendState)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pColorBlendState, sizeof(const VkPipelineColorBlendStateCreateInfo));
+ unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pDynamicState = (const VkPipelineDynamicStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDynamicState)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pDynamicState, sizeof(const VkPipelineDynamicStateCreateInfo));
+ unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
+ }
+ uint64_t cgen_var_81;
+ vkStream->read((uint64_t*)&cgen_var_81, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_81, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ uint64_t cgen_var_82;
+ vkStream->read((uint64_t*)&cgen_var_82, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_82, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
+ uint64_t cgen_var_83;
+ vkStream->read((uint64_t*)&cgen_var_83, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_83, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void marshal_VkComputePipelineCreateInfo(
+ VulkanStream* vkStream,
+ const VkComputePipelineCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
+ marshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
+ uint64_t cgen_var_84;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_84, 1);
+ vkStream->write((uint64_t*)&cgen_var_84, 1 * 8);
+ uint64_t cgen_var_85;
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_85, 1);
+ vkStream->write((uint64_t*)&cgen_var_85, 1 * 8);
+ vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void unmarshal_VkComputePipelineCreateInfo(
+ VulkanStream* vkStream,
+ VkComputePipelineCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
+ unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
+ uint64_t cgen_var_86;
+ vkStream->read((uint64_t*)&cgen_var_86, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_86, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ uint64_t cgen_var_87;
+ vkStream->read((uint64_t*)&cgen_var_87, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_87, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void marshal_VkPushConstantRange(
+ VulkanStream* vkStream,
+ const VkPushConstantRange* forMarshaling)
+{
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
+}
+
+void unmarshal_VkPushConstantRange(
+ VulkanStream* vkStream,
+ VkPushConstantRange* forUnmarshaling)
+{
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineLayoutCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineLayoutCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineLayoutCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineLayoutCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
+ if (forMarshaling->setLayoutCount)
+ {
+ uint64_t* cgen_var_88;
+ vkStream->alloc((void**)&cgen_var_88, forMarshaling->setLayoutCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_88, forMarshaling->setLayoutCount);
+ vkStream->write((uint64_t*)cgen_var_88, forMarshaling->setLayoutCount * 8);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
+ {
+ marshal_VkPushConstantRange(vkStream, (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
+ }
+}
+
+void unmarshal_VkPipelineLayoutCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineLayoutCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineLayoutCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineLayoutCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+ if (forUnmarshaling->setLayoutCount)
+ {
+ uint64_t* cgen_var_89;
+ vkStream->alloc((void**)&cgen_var_89, forUnmarshaling->setLayoutCount * 8);
+ vkStream->read((uint64_t*)cgen_var_89, forUnmarshaling->setLayoutCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_89, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount);
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pPushConstantRanges, forUnmarshaling->pushConstantRangeCount * sizeof(const VkPushConstantRange));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i)
+ {
+ unmarshal_VkPushConstantRange(vkStream, (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
+ }
+}
+
+void marshal_VkSamplerCreateInfo(
+ VulkanStream* vkStream,
+ const VkSamplerCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkSamplerCreateFlags*)&forMarshaling->flags, sizeof(VkSamplerCreateFlags));
+ vkStream->write((VkFilter*)&forMarshaling->magFilter, sizeof(VkFilter));
+ vkStream->write((VkFilter*)&forMarshaling->minFilter, sizeof(VkFilter));
+ vkStream->write((VkSamplerMipmapMode*)&forMarshaling->mipmapMode, sizeof(VkSamplerMipmapMode));
+ vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeU, sizeof(VkSamplerAddressMode));
+ vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeV, sizeof(VkSamplerAddressMode));
+ vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeW, sizeof(VkSamplerAddressMode));
+ vkStream->write((float*)&forMarshaling->mipLodBias, sizeof(float));
+ vkStream->write((VkBool32*)&forMarshaling->anisotropyEnable, sizeof(VkBool32));
+ vkStream->write((float*)&forMarshaling->maxAnisotropy, sizeof(float));
+ vkStream->write((VkBool32*)&forMarshaling->compareEnable, sizeof(VkBool32));
+ vkStream->write((VkCompareOp*)&forMarshaling->compareOp, sizeof(VkCompareOp));
+ vkStream->write((float*)&forMarshaling->minLod, sizeof(float));
+ vkStream->write((float*)&forMarshaling->maxLod, sizeof(float));
+ vkStream->write((VkBorderColor*)&forMarshaling->borderColor, sizeof(VkBorderColor));
+ vkStream->write((VkBool32*)&forMarshaling->unnormalizedCoordinates, sizeof(VkBool32));
+}
+
+void unmarshal_VkSamplerCreateInfo(
+ VulkanStream* vkStream,
+ VkSamplerCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkSamplerCreateFlags*)&forUnmarshaling->flags, sizeof(VkSamplerCreateFlags));
+ vkStream->read((VkFilter*)&forUnmarshaling->magFilter, sizeof(VkFilter));
+ vkStream->read((VkFilter*)&forUnmarshaling->minFilter, sizeof(VkFilter));
+ vkStream->read((VkSamplerMipmapMode*)&forUnmarshaling->mipmapMode, sizeof(VkSamplerMipmapMode));
+ vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeU, sizeof(VkSamplerAddressMode));
+ vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeV, sizeof(VkSamplerAddressMode));
+ vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeW, sizeof(VkSamplerAddressMode));
+ vkStream->read((float*)&forUnmarshaling->mipLodBias, sizeof(float));
+ vkStream->read((VkBool32*)&forUnmarshaling->anisotropyEnable, sizeof(VkBool32));
+ vkStream->read((float*)&forUnmarshaling->maxAnisotropy, sizeof(float));
+ vkStream->read((VkBool32*)&forUnmarshaling->compareEnable, sizeof(VkBool32));
+ vkStream->read((VkCompareOp*)&forUnmarshaling->compareOp, sizeof(VkCompareOp));
+ vkStream->read((float*)&forUnmarshaling->minLod, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->maxLod, sizeof(float));
+ vkStream->read((VkBorderColor*)&forUnmarshaling->borderColor, sizeof(VkBorderColor));
+ vkStream->read((VkBool32*)&forUnmarshaling->unnormalizedCoordinates, sizeof(VkBool32));
+}
+
+void marshal_VkDescriptorSetLayoutBinding(
+ VulkanStream* vkStream,
+ const VkDescriptorSetLayoutBinding* forMarshaling)
+{
+ 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));
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_90 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
+ vkStream->putBe64(cgen_var_90);
+ if (forMarshaling->pImmutableSamplers)
+ {
+ if (forMarshaling->descriptorCount)
+ {
+ uint64_t* cgen_var_91;
+ vkStream->alloc((void**)&cgen_var_91, forMarshaling->descriptorCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pImmutableSamplers, cgen_var_91, forMarshaling->descriptorCount);
+ vkStream->write((uint64_t*)cgen_var_91, forMarshaling->descriptorCount * 8);
+ }
+ }
+}
+
+void unmarshal_VkDescriptorSetLayoutBinding(
+ VulkanStream* vkStream,
+ VkDescriptorSetLayoutBinding* forUnmarshaling)
+{
+ 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));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ // WARNING PTR CHECK
+ forUnmarshaling->pImmutableSamplers = (const VkSampler*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pImmutableSamplers)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount * sizeof(const VkSampler));
+ if (forUnmarshaling->descriptorCount)
+ {
+ uint64_t* cgen_var_93;
+ vkStream->alloc((void**)&cgen_var_93, forUnmarshaling->descriptorCount * 8);
+ vkStream->read((uint64_t*)cgen_var_93, forUnmarshaling->descriptorCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSampler(cgen_var_93, (VkSampler*)forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount);
+ }
+ }
+}
+
+void marshal_VkDescriptorSetLayoutCreateInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorSetLayoutCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDescriptorSetLayoutCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorSetLayoutCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i)
+ {
+ marshal_VkDescriptorSetLayoutBinding(vkStream, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i));
+ }
+}
+
+void unmarshal_VkDescriptorSetLayoutCreateInfo(
+ VulkanStream* vkStream,
+ VkDescriptorSetLayoutCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDescriptorSetLayoutCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorSetLayoutCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pBindings, forUnmarshaling->bindingCount * sizeof(const VkDescriptorSetLayoutBinding));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindingCount; ++i)
+ {
+ unmarshal_VkDescriptorSetLayoutBinding(vkStream, (VkDescriptorSetLayoutBinding*)(forUnmarshaling->pBindings + i));
+ }
+}
+
+void marshal_VkDescriptorPoolSize(
+ VulkanStream* vkStream,
+ const VkDescriptorPoolSize* forMarshaling)
+{
+ vkStream->write((VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
+ vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorPoolSize(
+ VulkanStream* vkStream,
+ VkDescriptorPoolSize* forUnmarshaling)
+{
+ vkStream->read((VkDescriptorType*)&forUnmarshaling->type, sizeof(VkDescriptorType));
+ vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
+}
+
+void marshal_VkDescriptorPoolCreateInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorPoolCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i)
+ {
+ marshal_VkDescriptorPoolSize(vkStream, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i));
+ }
+}
+
+void unmarshal_VkDescriptorPoolCreateInfo(
+ VulkanStream* vkStream,
+ VkDescriptorPoolCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->alloc((void**)&forUnmarshaling->pPoolSizes, forUnmarshaling->poolSizeCount * sizeof(const VkDescriptorPoolSize));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->poolSizeCount; ++i)
+ {
+ unmarshal_VkDescriptorPoolSize(vkStream, (VkDescriptorPoolSize*)(forUnmarshaling->pPoolSizes + i));
+ }
+}
+
+void marshal_VkDescriptorSetAllocateInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorSetAllocateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_94;
+ vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_94, 1);
+ vkStream->write((uint64_t*)&cgen_var_94, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
+ if (forMarshaling->descriptorSetCount)
+ {
+ uint64_t* cgen_var_95;
+ vkStream->alloc((void**)&cgen_var_95, forMarshaling->descriptorSetCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_95, forMarshaling->descriptorSetCount);
+ vkStream->write((uint64_t*)cgen_var_95, forMarshaling->descriptorSetCount * 8);
+ }
+}
+
+void unmarshal_VkDescriptorSetAllocateInfo(
+ VulkanStream* vkStream,
+ VkDescriptorSetAllocateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_96;
+ vkStream->read((uint64_t*)&cgen_var_96, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_96, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
+ if (forUnmarshaling->descriptorSetCount)
+ {
+ uint64_t* cgen_var_97;
+ vkStream->alloc((void**)&cgen_var_97, forUnmarshaling->descriptorSetCount * 8);
+ vkStream->read((uint64_t*)cgen_var_97, forUnmarshaling->descriptorSetCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_97, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount);
+ }
+}
+
+void marshal_VkDescriptorImageInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorImageInfo* forMarshaling)
+{
+ uint64_t cgen_var_98;
+ vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_98, 1);
+ vkStream->write((uint64_t*)&cgen_var_98, 1 * 8);
+ uint64_t cgen_var_99;
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_99, 1);
+ vkStream->write((uint64_t*)&cgen_var_99, 1 * 8);
+ vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkDescriptorImageInfo(
+ VulkanStream* vkStream,
+ VkDescriptorImageInfo* forUnmarshaling)
+{
+ uint64_t cgen_var_100;
+ vkStream->read((uint64_t*)&cgen_var_100, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_100, (VkSampler*)&forUnmarshaling->sampler, 1);
+ uint64_t cgen_var_101;
+ vkStream->read((uint64_t*)&cgen_var_101, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_101, (VkImageView*)&forUnmarshaling->imageView, 1);
+ vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
+}
+
+void marshal_VkDescriptorBufferInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorBufferInfo* forMarshaling)
+{
+ uint64_t cgen_var_102;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_102, 1);
+ vkStream->write((uint64_t*)&cgen_var_102, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkDescriptorBufferInfo(
+ VulkanStream* vkStream,
+ VkDescriptorBufferInfo* forUnmarshaling)
+{
+ uint64_t cgen_var_103;
+ vkStream->read((uint64_t*)&cgen_var_103, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_103, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
+}
+
+void marshal_VkWriteDescriptorSet(
+ VulkanStream* vkStream,
+ const VkWriteDescriptorSet* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_104;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_104, 1);
+ vkStream->write((uint64_t*)&cgen_var_104, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
+ vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_105 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
+ vkStream->putBe64(cgen_var_105);
+ if (forMarshaling->pImageInfo)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
+ {
+ marshal_VkDescriptorImageInfo(vkStream, (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_106 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
+ vkStream->putBe64(cgen_var_106);
+ if (forMarshaling->pBufferInfo)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
+ {
+ marshal_VkDescriptorBufferInfo(vkStream, (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_107 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
+ vkStream->putBe64(cgen_var_107);
+ if (forMarshaling->pTexelBufferView)
+ {
+ if (forMarshaling->descriptorCount)
+ {
+ uint64_t* cgen_var_108;
+ vkStream->alloc((void**)&cgen_var_108, forMarshaling->descriptorCount * 8);
+ vkStream->handleMapping()->mapHandles_VkBufferView_u64(forMarshaling->pTexelBufferView, cgen_var_108, forMarshaling->descriptorCount);
+ vkStream->write((uint64_t*)cgen_var_108, forMarshaling->descriptorCount * 8);
+ }
+ }
+}
+
+void unmarshal_VkWriteDescriptorSet(
+ VulkanStream* vkStream,
+ VkWriteDescriptorSet* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_109;
+ vkStream->read((uint64_t*)&cgen_var_109, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_109, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
+ vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
+ // WARNING PTR CHECK
+ forUnmarshaling->pImageInfo = (const VkDescriptorImageInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pImageInfo)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pImageInfo, forUnmarshaling->descriptorCount * sizeof(const VkDescriptorImageInfo));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
+ {
+ unmarshal_VkDescriptorImageInfo(vkStream, (VkDescriptorImageInfo*)(forUnmarshaling->pImageInfo + i));
+ }
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pBufferInfo = (const VkDescriptorBufferInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pBufferInfo)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pBufferInfo, forUnmarshaling->descriptorCount * sizeof(const VkDescriptorBufferInfo));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
+ {
+ unmarshal_VkDescriptorBufferInfo(vkStream, (VkDescriptorBufferInfo*)(forUnmarshaling->pBufferInfo + i));
+ }
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pTexelBufferView = (const VkBufferView*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pTexelBufferView)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount * sizeof(const VkBufferView));
+ if (forUnmarshaling->descriptorCount)
+ {
+ uint64_t* cgen_var_113;
+ vkStream->alloc((void**)&cgen_var_113, forUnmarshaling->descriptorCount * 8);
+ vkStream->read((uint64_t*)cgen_var_113, forUnmarshaling->descriptorCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBufferView(cgen_var_113, (VkBufferView*)forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount);
+ }
+ }
+}
+
+void marshal_VkCopyDescriptorSet(
+ VulkanStream* vkStream,
+ const VkCopyDescriptorSet* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_114;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_114, 1);
+ vkStream->write((uint64_t*)&cgen_var_114, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->srcBinding, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->srcArrayElement, sizeof(uint32_t));
+ uint64_t cgen_var_115;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_115, 1);
+ vkStream->write((uint64_t*)&cgen_var_115, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkCopyDescriptorSet(
+ VulkanStream* vkStream,
+ VkCopyDescriptorSet* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_116;
+ vkStream->read((uint64_t*)&cgen_var_116, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_116, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->srcBinding, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->srcArrayElement, sizeof(uint32_t));
+ uint64_t cgen_var_117;
+ vkStream->read((uint64_t*)&cgen_var_117, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_117, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
+}
+
+void marshal_VkFramebufferCreateInfo(
+ VulkanStream* vkStream,
+ const VkFramebufferCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
+ uint64_t cgen_var_118;
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_118, 1);
+ vkStream->write((uint64_t*)&cgen_var_118, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
+ if (forMarshaling->attachmentCount)
+ {
+ uint64_t* cgen_var_119;
+ vkStream->alloc((void**)&cgen_var_119, forMarshaling->attachmentCount * 8);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_119, forMarshaling->attachmentCount);
+ vkStream->write((uint64_t*)cgen_var_119, forMarshaling->attachmentCount * 8);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->layers, sizeof(uint32_t));
+}
+
+void unmarshal_VkFramebufferCreateInfo(
+ VulkanStream* vkStream,
+ VkFramebufferCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkFramebufferCreateFlags));
+ uint64_t cgen_var_120;
+ vkStream->read((uint64_t*)&cgen_var_120, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_120, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount * sizeof(const VkImageView));
+ if (forUnmarshaling->attachmentCount)
+ {
+ uint64_t* cgen_var_121;
+ vkStream->alloc((void**)&cgen_var_121, forUnmarshaling->attachmentCount * 8);
+ vkStream->read((uint64_t*)cgen_var_121, forUnmarshaling->attachmentCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_121, (VkImageView*)forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount);
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->layers, sizeof(uint32_t));
+}
+
+void marshal_VkAttachmentDescription(
+ VulkanStream* vkStream,
+ const VkAttachmentDescription* forMarshaling)
+{
+ vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+ vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+ vkStream->write((VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
+ vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+ vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
+ vkStream->write((VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkAttachmentDescription(
+ VulkanStream* vkStream,
+ VkAttachmentDescription* forUnmarshaling)
+{
+ vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+ vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+ vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
+ vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+ vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
+ vkStream->read((VkImageLayout*)&forUnmarshaling->finalLayout, sizeof(VkImageLayout));
+}
+
+void marshal_VkAttachmentReference(
+ VulkanStream* vkStream,
+ const VkAttachmentReference* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
+ vkStream->write((VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkAttachmentReference(
+ VulkanStream* vkStream,
+ VkAttachmentReference* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->attachment, sizeof(uint32_t));
+ vkStream->read((VkImageLayout*)&forUnmarshaling->layout, sizeof(VkImageLayout));
+}
+
+void marshal_VkSubpassDescription(
+ VulkanStream* vkStream,
+ const VkSubpassDescription* forMarshaling)
+{
+ vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags, sizeof(VkSubpassDescriptionFlags));
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->write((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
+ {
+ marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
+ {
+ marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_122 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+ vkStream->putBe64(cgen_var_122);
+ if (forMarshaling->pResolveAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
+ {
+ marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_123 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+ vkStream->putBe64(cgen_var_123);
+ if (forMarshaling->pDepthStencilAttachment)
+ {
+ marshal_VkAttachmentReference(vkStream, (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));
+}
+
+void unmarshal_VkSubpassDescription(
+ VulkanStream* vkStream,
+ VkSubpassDescription* forUnmarshaling)
+{
+ vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkSubpassDescriptionFlags));
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pInputAttachments, forUnmarshaling->inputAttachmentCount * sizeof(const VkAttachmentReference));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i)
+ {
+ unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pInputAttachments + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pColorAttachments, forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
+ {
+ unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pColorAttachments + i));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pResolveAttachments = (const VkAttachmentReference*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pResolveAttachments)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pResolveAttachments, forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
+ {
+ unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pResolveAttachments + i));
+ }
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pDepthStencilAttachment = (const VkAttachmentReference*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDepthStencilAttachment)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pDepthStencilAttachment, sizeof(const VkAttachmentReference));
+ unmarshal_VkAttachmentReference(vkStream, (VkAttachmentReference*)(forUnmarshaling->pDepthStencilAttachment));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->preserveAttachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+}
+
+void marshal_VkSubpassDependency(
+ VulkanStream* vkStream,
+ const VkSubpassDependency* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+ vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+ vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+}
+
+void unmarshal_VkSubpassDependency(
+ VulkanStream* vkStream,
+ VkSubpassDependency* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->srcSubpass, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->dstSubpass, sizeof(uint32_t));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+ vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+ vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+}
+
+void marshal_VkRenderPassCreateInfo(
+ VulkanStream* vkStream,
+ const VkRenderPassCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
+ {
+ marshal_VkAttachmentDescription(vkStream, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
+ {
+ marshal_VkSubpassDescription(vkStream, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
+ {
+ marshal_VkSubpassDependency(vkStream, (const VkSubpassDependency*)(forMarshaling->pDependencies + i));
+ }
+}
+
+void unmarshal_VkRenderPassCreateInfo(
+ VulkanStream* vkStream,
+ VkRenderPassCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags, sizeof(VkRenderPassCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount * sizeof(const VkAttachmentDescription));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
+ {
+ unmarshal_VkAttachmentDescription(vkStream, (VkAttachmentDescription*)(forUnmarshaling->pAttachments + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSubpasses, forUnmarshaling->subpassCount * sizeof(const VkSubpassDescription));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i)
+ {
+ unmarshal_VkSubpassDescription(vkStream, (VkSubpassDescription*)(forUnmarshaling->pSubpasses + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDependencies, forUnmarshaling->dependencyCount * sizeof(const VkSubpassDependency));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i)
+ {
+ unmarshal_VkSubpassDependency(vkStream, (VkSubpassDependency*)(forUnmarshaling->pDependencies + i));
+ }
+}
+
+void marshal_VkCommandPoolCreateInfo(
+ VulkanStream* vkStream,
+ const VkCommandPoolCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkCommandPoolCreateFlags*)&forMarshaling->flags, sizeof(VkCommandPoolCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkCommandPoolCreateInfo(
+ VulkanStream* vkStream,
+ VkCommandPoolCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkCommandPoolCreateFlags*)&forUnmarshaling->flags, sizeof(VkCommandPoolCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
+}
+
+void marshal_VkCommandBufferAllocateInfo(
+ VulkanStream* vkStream,
+ const VkCommandBufferAllocateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_126;
+ vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_126, 1);
+ vkStream->write((uint64_t*)&cgen_var_126, 1 * 8);
+ vkStream->write((VkCommandBufferLevel*)&forMarshaling->level, sizeof(VkCommandBufferLevel));
+ vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkCommandBufferAllocateInfo(
+ VulkanStream* vkStream,
+ VkCommandBufferAllocateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_127;
+ vkStream->read((uint64_t*)&cgen_var_127, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_127, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
+ vkStream->read((VkCommandBufferLevel*)&forUnmarshaling->level, sizeof(VkCommandBufferLevel));
+ vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
+}
+
+void marshal_VkCommandBufferInheritanceInfo(
+ VulkanStream* vkStream,
+ const VkCommandBufferInheritanceInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_128;
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_128, 1);
+ vkStream->write((uint64_t*)&cgen_var_128, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
+ uint64_t cgen_var_129;
+ vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_129, 1);
+ vkStream->write((uint64_t*)&cgen_var_129, 1 * 8);
+ vkStream->write((VkBool32*)&forMarshaling->occlusionQueryEnable, sizeof(VkBool32));
+ vkStream->write((VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
+ vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+}
+
+void unmarshal_VkCommandBufferInheritanceInfo(
+ VulkanStream* vkStream,
+ VkCommandBufferInheritanceInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_130;
+ vkStream->read((uint64_t*)&cgen_var_130, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_130, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
+ uint64_t cgen_var_131;
+ vkStream->read((uint64_t*)&cgen_var_131, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_131, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+ vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryEnable, sizeof(VkBool32));
+ vkStream->read((VkQueryControlFlags*)&forUnmarshaling->queryFlags, sizeof(VkQueryControlFlags));
+ vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+}
+
+void marshal_VkCommandBufferBeginInfo(
+ VulkanStream* vkStream,
+ const VkCommandBufferBeginInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags, sizeof(VkCommandBufferUsageFlags));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_132 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
+ vkStream->putBe64(cgen_var_132);
+ if (forMarshaling->pInheritanceInfo)
+ {
+ marshal_VkCommandBufferInheritanceInfo(vkStream, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
+ }
+}
+
+void unmarshal_VkCommandBufferBeginInfo(
+ VulkanStream* vkStream,
+ VkCommandBufferBeginInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkCommandBufferUsageFlags*)&forUnmarshaling->flags, sizeof(VkCommandBufferUsageFlags));
+ // WARNING PTR CHECK
+ forUnmarshaling->pInheritanceInfo = (const VkCommandBufferInheritanceInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pInheritanceInfo)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pInheritanceInfo, sizeof(const VkCommandBufferInheritanceInfo));
+ unmarshal_VkCommandBufferInheritanceInfo(vkStream, (VkCommandBufferInheritanceInfo*)(forUnmarshaling->pInheritanceInfo));
+ }
+}
+
+void marshal_VkBufferCopy(
+ VulkanStream* vkStream,
+ const VkBufferCopy* forMarshaling)
+{
+ vkStream->write((VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBufferCopy(
+ VulkanStream* vkStream,
+ VkBufferCopy* forUnmarshaling)
+{
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->srcOffset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->dstOffset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkImageSubresourceLayers(
+ VulkanStream* vkStream,
+ const VkImageSubresourceLayers* forMarshaling)
+{
+ 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));
+ vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkImageSubresourceLayers(
+ VulkanStream* vkStream,
+ VkImageSubresourceLayers* forUnmarshaling)
+{
+ 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));
+ vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
+}
+
+void marshal_VkImageCopy(
+ VulkanStream* vkStream,
+ 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 unmarshal_VkImageCopy(
+ VulkanStream* vkStream,
+ 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 marshal_VkImageBlit(
+ VulkanStream* vkStream,
+ const VkImageBlit* forMarshaling)
+{
+ marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ {
+ marshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->srcOffsets + i));
+ }
+ marshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ {
+ marshal_VkOffset3D(vkStream, (VkOffset3D*)(forMarshaling->dstOffsets + i));
+ }
+}
+
+void unmarshal_VkImageBlit(
+ VulkanStream* vkStream,
+ VkImageBlit* forUnmarshaling)
+{
+ unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ {
+ unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
+ }
+ unmarshal_VkImageSubresourceLayers(vkStream, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i)
+ {
+ unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
+ }
+}
+
+void marshal_VkBufferImageCopy(
+ VulkanStream* vkStream,
+ const VkBufferImageCopy* forMarshaling)
+{
+ 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));
+}
+
+void unmarshal_VkBufferImageCopy(
+ VulkanStream* vkStream,
+ VkBufferImageCopy* forUnmarshaling)
+{
+ 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));
+}
+
+void marshal_VkClearColorValue(
+ VulkanStream* vkStream,
+ const VkClearColorValue* forMarshaling)
+{
+ vkStream->write((float*)forMarshaling->float32, 4 * sizeof(float));
+}
+
+void unmarshal_VkClearColorValue(
+ VulkanStream* vkStream,
+ VkClearColorValue* forUnmarshaling)
+{
+ vkStream->read((float*)forUnmarshaling->float32, 4 * sizeof(float));
+}
+
+void marshal_VkClearDepthStencilValue(
+ VulkanStream* vkStream,
+ const VkClearDepthStencilValue* forMarshaling)
+{
+ vkStream->write((float*)&forMarshaling->depth, sizeof(float));
+ vkStream->write((uint32_t*)&forMarshaling->stencil, sizeof(uint32_t));
+}
+
+void unmarshal_VkClearDepthStencilValue(
+ VulkanStream* vkStream,
+ VkClearDepthStencilValue* forUnmarshaling)
+{
+ vkStream->read((float*)&forUnmarshaling->depth, sizeof(float));
+ vkStream->read((uint32_t*)&forUnmarshaling->stencil, sizeof(uint32_t));
+}
+
+void marshal_VkClearValue(
+ VulkanStream* vkStream,
+ const VkClearValue* forMarshaling)
+{
+ marshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forMarshaling->color));
+}
+
+void unmarshal_VkClearValue(
+ VulkanStream* vkStream,
+ VkClearValue* forUnmarshaling)
+{
+ unmarshal_VkClearColorValue(vkStream, (VkClearColorValue*)(&forUnmarshaling->color));
+}
+
+void marshal_VkClearAttachment(
+ VulkanStream* vkStream,
+ const VkClearAttachment* forMarshaling)
+{
+ vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+ vkStream->write((uint32_t*)&forMarshaling->colorAttachment, sizeof(uint32_t));
+ marshal_VkClearValue(vkStream, (VkClearValue*)(&forMarshaling->clearValue));
+}
+
+void unmarshal_VkClearAttachment(
+ VulkanStream* vkStream,
+ VkClearAttachment* forUnmarshaling)
+{
+ vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->colorAttachment, sizeof(uint32_t));
+ unmarshal_VkClearValue(vkStream, (VkClearValue*)(&forUnmarshaling->clearValue));
+}
+
+void marshal_VkClearRect(
+ VulkanStream* vkStream,
+ const VkClearRect* forMarshaling)
+{
+ marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->rect));
+ vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkClearRect(
+ VulkanStream* vkStream,
+ VkClearRect* forUnmarshaling)
+{
+ unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->rect));
+ vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
+}
+
+void marshal_VkImageResolve(
+ VulkanStream* vkStream,
+ 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 unmarshal_VkImageResolve(
+ VulkanStream* vkStream,
+ 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 marshal_VkMemoryBarrier(
+ VulkanStream* vkStream,
+ const VkMemoryBarrier* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+ vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+}
+
+void unmarshal_VkMemoryBarrier(
+ VulkanStream* vkStream,
+ VkMemoryBarrier* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+ vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+}
+
+void marshal_VkBufferMemoryBarrier(
+ VulkanStream* vkStream,
+ const VkBufferMemoryBarrier* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+ uint64_t cgen_var_134;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_134, 1);
+ vkStream->write((uint64_t*)&cgen_var_134, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBufferMemoryBarrier(
+ VulkanStream* vkStream,
+ VkBufferMemoryBarrier* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+ uint64_t cgen_var_135;
+ vkStream->read((uint64_t*)&cgen_var_135, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_135, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkImageMemoryBarrier(
+ VulkanStream* vkStream,
+ const VkImageMemoryBarrier* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+ vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+ vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
+ vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
+ vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+ uint64_t cgen_var_136;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_136, 1);
+ vkStream->write((uint64_t*)&cgen_var_136, 1 * 8);
+ marshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+}
+
+void unmarshal_VkImageMemoryBarrier(
+ VulkanStream* vkStream,
+ VkImageMemoryBarrier* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+ vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+ vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
+ vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
+ vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+ uint64_t cgen_var_137;
+ vkStream->read((uint64_t*)&cgen_var_137, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_137, (VkImage*)&forUnmarshaling->image, 1);
+ unmarshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+}
+
+void marshal_VkRenderPassBeginInfo(
+ VulkanStream* vkStream,
+ const VkRenderPassBeginInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_138;
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_138, 1);
+ vkStream->write((uint64_t*)&cgen_var_138, 1 * 8);
+ uint64_t cgen_var_139;
+ vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_139, 1);
+ vkStream->write((uint64_t*)&cgen_var_139, 1 * 8);
+ marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea));
+ vkStream->write((uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_140 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
+ vkStream->putBe64(cgen_var_140);
+ if (forMarshaling->pClearValues)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
+ {
+ marshal_VkClearValue(vkStream, (const VkClearValue*)(forMarshaling->pClearValues + i));
+ }
+ }
+}
+
+void unmarshal_VkRenderPassBeginInfo(
+ VulkanStream* vkStream,
+ VkRenderPassBeginInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_141;
+ vkStream->read((uint64_t*)&cgen_var_141, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_141, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ uint64_t cgen_var_142;
+ vkStream->read((uint64_t*)&cgen_var_142, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_142, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+ unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->renderArea));
+ vkStream->read((uint32_t*)&forUnmarshaling->clearValueCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pClearValues = (const VkClearValue*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pClearValues)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pClearValues, forUnmarshaling->clearValueCount * sizeof(const VkClearValue));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->clearValueCount; ++i)
+ {
+ unmarshal_VkClearValue(vkStream, (VkClearValue*)(forUnmarshaling->pClearValues + i));
+ }
+ }
+}
+
+void marshal_VkDispatchIndirectCommand(
+ VulkanStream* vkStream,
+ const VkDispatchIndirectCommand* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->x, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->y, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->z, sizeof(uint32_t));
+}
+
+void unmarshal_VkDispatchIndirectCommand(
+ VulkanStream* vkStream,
+ VkDispatchIndirectCommand* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->x, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->y, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->z, sizeof(uint32_t));
+}
+
+void marshal_VkDrawIndexedIndirectCommand(
+ VulkanStream* vkStream,
+ const VkDrawIndexedIndirectCommand* forMarshaling)
+{
+ 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));
+ vkStream->write((int32_t*)&forMarshaling->vertexOffset, sizeof(int32_t));
+ vkStream->write((uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
+}
+
+void unmarshal_VkDrawIndexedIndirectCommand(
+ VulkanStream* vkStream,
+ VkDrawIndexedIndirectCommand* forUnmarshaling)
+{
+ 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));
+ vkStream->read((int32_t*)&forUnmarshaling->vertexOffset, sizeof(int32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->firstInstance, sizeof(uint32_t));
+}
+
+void marshal_VkDrawIndirectCommand(
+ VulkanStream* vkStream,
+ const VkDrawIndirectCommand* forMarshaling)
+{
+ 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));
+ vkStream->write((uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
+}
+
+void unmarshal_VkDrawIndirectCommand(
+ VulkanStream* vkStream,
+ VkDrawIndirectCommand* forUnmarshaling)
+{
+ 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));
+ vkStream->read((uint32_t*)&forUnmarshaling->firstInstance, sizeof(uint32_t));
+}
+
+void marshal_VkBaseOutStructure(
+ VulkanStream* vkStream,
+ const VkBaseOutStructure* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((VkBaseOutStructure*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+}
+
+void unmarshal_VkBaseOutStructure(
+ VulkanStream* vkStream,
+ VkBaseOutStructure* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((VkBaseOutStructure*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+}
+
+void marshal_VkBaseInStructure(
+ VulkanStream* vkStream,
+ const VkBaseInStructure* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const VkBaseInStructure*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+}
+
+void unmarshal_VkBaseInStructure(
+ VulkanStream* vkStream,
+ VkBaseInStructure* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((VkBaseInStructure*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+}
+
+#endif
+#ifdef VK_VERSION_1_1
+void marshal_VkPhysicalDeviceSubgroupProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSubgroupProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->supportedStages, sizeof(VkShaderStageFlags));
+ vkStream->write((VkSubgroupFeatureFlags*)&forMarshaling->supportedOperations, sizeof(VkSubgroupFeatureFlags));
+ vkStream->write((VkBool32*)&forMarshaling->quadOperationsInAllStages, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSubgroupProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSubgroupProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->subgroupSize, sizeof(uint32_t));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->supportedStages, sizeof(VkShaderStageFlags));
+ vkStream->read((VkSubgroupFeatureFlags*)&forUnmarshaling->supportedOperations, sizeof(VkSubgroupFeatureFlags));
+ vkStream->read((VkBool32*)&forUnmarshaling->quadOperationsInAllStages, sizeof(VkBool32));
+}
+
+void marshal_VkBindBufferMemoryInfo(
+ VulkanStream* vkStream,
+ const VkBindBufferMemoryInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_144;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_144, 1);
+ vkStream->write((uint64_t*)&cgen_var_144, 1 * 8);
+ uint64_t cgen_var_145;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_145, 1);
+ vkStream->write((uint64_t*)&cgen_var_145, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBindBufferMemoryInfo(
+ VulkanStream* vkStream,
+ VkBindBufferMemoryInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_146;
+ vkStream->read((uint64_t*)&cgen_var_146, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_146, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_147;
+ vkStream->read((uint64_t*)&cgen_var_147, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_147, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
+}
+
+void marshal_VkBindImageMemoryInfo(
+ VulkanStream* vkStream,
+ const VkBindImageMemoryInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_148;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_148, 1);
+ vkStream->write((uint64_t*)&cgen_var_148, 1 * 8);
+ uint64_t cgen_var_149;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_149, 1);
+ vkStream->write((uint64_t*)&cgen_var_149, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBindImageMemoryInfo(
+ VulkanStream* vkStream,
+ VkBindImageMemoryInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_150;
+ vkStream->read((uint64_t*)&cgen_var_150, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_150, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_151;
+ vkStream->read((uint64_t*)&cgen_var_151, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_151, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
+}
+
+void marshal_VkPhysicalDevice16BitStorageFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDevice16BitStorageFeatures* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->storagePushConstant16, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->storageInputOutput16, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevice16BitStorageFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDevice16BitStorageFeatures* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant16, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->storageInputOutput16, sizeof(VkBool32));
+}
+
+void marshal_VkMemoryDedicatedRequirements(
+ VulkanStream* vkStream,
+ const VkMemoryDedicatedRequirements* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkMemoryDedicatedRequirements(
+ VulkanStream* vkStream,
+ VkMemoryDedicatedRequirements* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->prefersDedicatedAllocation, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
+}
+
+void marshal_VkMemoryDedicatedAllocateInfo(
+ VulkanStream* vkStream,
+ const VkMemoryDedicatedAllocateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_152;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_152, 1);
+ vkStream->write((uint64_t*)&cgen_var_152, 1 * 8);
+ uint64_t cgen_var_153;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_153, 1);
+ vkStream->write((uint64_t*)&cgen_var_153, 1 * 8);
+}
+
+void unmarshal_VkMemoryDedicatedAllocateInfo(
+ VulkanStream* vkStream,
+ VkMemoryDedicatedAllocateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_154;
+ vkStream->read((uint64_t*)&cgen_var_154, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_154, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_155;
+ vkStream->read((uint64_t*)&cgen_var_155, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_155, (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+void marshal_VkMemoryAllocateFlagsInfo(
+ VulkanStream* vkStream,
+ const VkMemoryAllocateFlagsInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkMemoryAllocateFlags*)&forMarshaling->flags, sizeof(VkMemoryAllocateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryAllocateFlagsInfo(
+ VulkanStream* vkStream,
+ VkMemoryAllocateFlagsInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkMemoryAllocateFlags*)&forUnmarshaling->flags, sizeof(VkMemoryAllocateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void marshal_VkDeviceGroupRenderPassBeginInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupRenderPassBeginInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->deviceRenderAreaCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->deviceRenderAreaCount; ++i)
+ {
+ marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i));
+ }
+}
+
+void unmarshal_VkDeviceGroupRenderPassBeginInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupRenderPassBeginInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceRenderAreaCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDeviceRenderAreas, forUnmarshaling->deviceRenderAreaCount * sizeof(const VkRect2D));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->deviceRenderAreaCount; ++i)
+ {
+ unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pDeviceRenderAreas + i));
+ }
+}
+
+void marshal_VkDeviceGroupCommandBufferBeginInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupCommandBufferBeginInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void marshal_VkDeviceGroupSubmitInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupSubmitInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((const uint32_t*)forMarshaling->pCommandBufferDeviceMasks, forMarshaling->commandBufferCount * sizeof(const uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pSignalSemaphoreDeviceIndices, forMarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkDeviceGroupSubmitInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupSubmitInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreDeviceIndices, forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pWaitSemaphoreDeviceIndices, forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pCommandBufferDeviceMasks, forUnmarshaling->commandBufferCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCommandBufferDeviceMasks, forUnmarshaling->commandBufferCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphoreDeviceIndices, forUnmarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pSignalSemaphoreDeviceIndices, forUnmarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+}
+
+void marshal_VkDeviceGroupBindSparseInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupBindSparseInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->resourceDeviceIndex, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->memoryDeviceIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkDeviceGroupBindSparseInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupBindSparseInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->resourceDeviceIndex, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryDeviceIndex, sizeof(uint32_t));
+}
+
+void marshal_VkBindBufferMemoryDeviceGroupInfo(
+ VulkanStream* vkStream,
+ const VkBindBufferMemoryDeviceGroupInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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(
+ VulkanStream* vkStream,
+ VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+}
+
+void marshal_VkBindImageMemoryDeviceGroupInfo(
+ VulkanStream* vkStream,
+ const VkBindImageMemoryDeviceGroupInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i)
+ {
+ marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i));
+ }
+}
+
+void unmarshal_VkBindImageMemoryDeviceGroupInfo(
+ VulkanStream* vkStream,
+ VkBindImageMemoryDeviceGroupInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSplitInstanceBindRegions, forUnmarshaling->splitInstanceBindRegionCount * sizeof(const VkRect2D));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->splitInstanceBindRegionCount; ++i)
+ {
+ unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pSplitInstanceBindRegions + i));
+ }
+}
+
+void marshal_VkPhysicalDeviceGroupProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceGroupProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+}
+
+void unmarshal_VkPhysicalDeviceGroupProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceGroupProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+}
+
+void marshal_VkDeviceGroupDeviceCreateInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupDeviceCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
+ if (forMarshaling->physicalDeviceCount)
+ {
+ uint64_t* cgen_var_156;
+ vkStream->alloc((void**)&cgen_var_156, forMarshaling->physicalDeviceCount * 8);
+ vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(forMarshaling->pPhysicalDevices, cgen_var_156, forMarshaling->physicalDeviceCount);
+ vkStream->write((uint64_t*)cgen_var_156, forMarshaling->physicalDeviceCount * 8);
+ }
+}
+
+void unmarshal_VkDeviceGroupDeviceCreateInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupDeviceCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount * sizeof(const VkPhysicalDevice));
+ if (forUnmarshaling->physicalDeviceCount)
+ {
+ uint64_t* cgen_var_157;
+ vkStream->alloc((void**)&cgen_var_157, forUnmarshaling->physicalDeviceCount * 8);
+ vkStream->read((uint64_t*)cgen_var_157, forUnmarshaling->physicalDeviceCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_157, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount);
+ }
+}
+
+void marshal_VkBufferMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ const VkBufferMemoryRequirementsInfo2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_158;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_158, 1);
+ vkStream->write((uint64_t*)&cgen_var_158, 1 * 8);
+}
+
+void unmarshal_VkBufferMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ VkBufferMemoryRequirementsInfo2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_159;
+ vkStream->read((uint64_t*)&cgen_var_159, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_159, (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+void marshal_VkImageMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ const VkImageMemoryRequirementsInfo2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_160;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_160, 1);
+ vkStream->write((uint64_t*)&cgen_var_160, 1 * 8);
+}
+
+void unmarshal_VkImageMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ VkImageMemoryRequirementsInfo2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_161;
+ vkStream->read((uint64_t*)&cgen_var_161, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_161, (VkImage*)&forUnmarshaling->image, 1);
+}
+
+void marshal_VkImageSparseMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ const VkImageSparseMemoryRequirementsInfo2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_162;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_162, 1);
+ vkStream->write((uint64_t*)&cgen_var_162, 1 * 8);
+}
+
+void unmarshal_VkImageSparseMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ VkImageSparseMemoryRequirementsInfo2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_163;
+ vkStream->read((uint64_t*)&cgen_var_163, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_163, (VkImage*)&forUnmarshaling->image, 1);
+}
+
+void marshal_VkMemoryRequirements2(
+ VulkanStream* vkStream,
+ const VkMemoryRequirements2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
+}
+
+void unmarshal_VkMemoryRequirements2(
+ VulkanStream* vkStream,
+ VkMemoryRequirements2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkMemoryRequirements(vkStream, (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
+}
+
+void marshal_VkSparseImageMemoryRequirements2(
+ VulkanStream* vkStream,
+ const VkSparseImageMemoryRequirements2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements));
+}
+
+void unmarshal_VkSparseImageMemoryRequirements2(
+ VulkanStream* vkStream,
+ VkSparseImageMemoryRequirements2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkSparseImageMemoryRequirements(vkStream, (VkSparseImageMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
+}
+
+void marshal_VkPhysicalDeviceFeatures2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceFeatures2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forMarshaling->features));
+}
+
+void unmarshal_VkPhysicalDeviceFeatures2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceFeatures2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkPhysicalDeviceFeatures(vkStream, (VkPhysicalDeviceFeatures*)(&forUnmarshaling->features));
+}
+
+void marshal_VkPhysicalDeviceProperties2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceProperties2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forMarshaling->properties));
+}
+
+void unmarshal_VkPhysicalDeviceProperties2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceProperties2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkPhysicalDeviceProperties(vkStream, (VkPhysicalDeviceProperties*)(&forUnmarshaling->properties));
+}
+
+void marshal_VkFormatProperties2(
+ VulkanStream* vkStream,
+ const VkFormatProperties2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forMarshaling->formatProperties));
+}
+
+void unmarshal_VkFormatProperties2(
+ VulkanStream* vkStream,
+ VkFormatProperties2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkFormatProperties(vkStream, (VkFormatProperties*)(&forUnmarshaling->formatProperties));
+}
+
+void marshal_VkImageFormatProperties2(
+ VulkanStream* vkStream,
+ const VkImageFormatProperties2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
+}
+
+void unmarshal_VkImageFormatProperties2(
+ VulkanStream* vkStream,
+ VkImageFormatProperties2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
+}
+
+void marshal_VkPhysicalDeviceImageFormatInfo2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceImageFormatInfo2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+ vkStream->write((VkImageType*)&forMarshaling->type, sizeof(VkImageType));
+ vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
+ vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
+}
+
+void unmarshal_VkPhysicalDeviceImageFormatInfo2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceImageFormatInfo2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+ vkStream->read((VkImageType*)&forUnmarshaling->type, sizeof(VkImageType));
+ vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
+ vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
+}
+
+void marshal_VkQueueFamilyProperties2(
+ VulkanStream* vkStream,
+ const VkQueueFamilyProperties2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties));
+}
+
+void unmarshal_VkQueueFamilyProperties2(
+ VulkanStream* vkStream,
+ VkQueueFamilyProperties2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkQueueFamilyProperties(vkStream, (VkQueueFamilyProperties*)(&forUnmarshaling->queueFamilyProperties));
+}
+
+void marshal_VkPhysicalDeviceMemoryProperties2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMemoryProperties2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties));
+}
+
+void unmarshal_VkPhysicalDeviceMemoryProperties2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMemoryProperties2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkPhysicalDeviceMemoryProperties(vkStream, (VkPhysicalDeviceMemoryProperties*)(&forUnmarshaling->memoryProperties));
+}
+
+void marshal_VkSparseImageFormatProperties2(
+ VulkanStream* vkStream,
+ const VkSparseImageFormatProperties2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forMarshaling->properties));
+}
+
+void unmarshal_VkSparseImageFormatProperties2(
+ VulkanStream* vkStream,
+ VkSparseImageFormatProperties2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkSparseImageFormatProperties(vkStream, (VkSparseImageFormatProperties*)(&forUnmarshaling->properties));
+}
+
+void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+ vkStream->write((VkImageType*)&forMarshaling->type, sizeof(VkImageType));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
+ vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
+}
+
+void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+ vkStream->read((VkImageType*)&forUnmarshaling->type, sizeof(VkImageType));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
+ vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
+}
+
+void marshal_VkPhysicalDevicePointClippingProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDevicePointClippingProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+}
+
+void unmarshal_VkPhysicalDevicePointClippingProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDevicePointClippingProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+}
+
+void marshal_VkInputAttachmentAspectReference(
+ VulkanStream* vkStream,
+ const VkInputAttachmentAspectReference* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->inputAttachmentIndex, sizeof(uint32_t));
+ vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
+}
+
+void unmarshal_VkInputAttachmentAspectReference(
+ VulkanStream* vkStream,
+ VkInputAttachmentAspectReference* forUnmarshaling)
+{
+ 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));
+}
+
+void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
+ VulkanStream* vkStream,
+ const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->aspectReferenceCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->aspectReferenceCount; ++i)
+ {
+ marshal_VkInputAttachmentAspectReference(vkStream, (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i));
+ }
+}
+
+void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
+ VulkanStream* vkStream,
+ VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->aspectReferenceCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAspectReferences, forUnmarshaling->aspectReferenceCount * sizeof(const VkInputAttachmentAspectReference));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->aspectReferenceCount; ++i)
+ {
+ unmarshal_VkInputAttachmentAspectReference(vkStream, (VkInputAttachmentAspectReference*)(forUnmarshaling->pAspectReferences + i));
+ }
+}
+
+void marshal_VkImageViewUsageCreateInfo(
+ VulkanStream* vkStream,
+ const VkImageViewUsageCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
+}
+
+void unmarshal_VkImageViewUsageCreateInfo(
+ VulkanStream* vkStream,
+ VkImageViewUsageCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
+}
+
+void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkTessellationDomainOrigin*)&forMarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
+}
+
+void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkTessellationDomainOrigin*)&forUnmarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
+}
+
+void marshal_VkRenderPassMultiviewCreateInfo(
+ VulkanStream* vkStream,
+ const VkRenderPassMultiviewCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((const int32_t*)forMarshaling->pViewOffsets, forMarshaling->dependencyCount * sizeof(const int32_t));
+ vkStream->write((uint32_t*)&forMarshaling->correlationMaskCount, sizeof(uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pCorrelationMasks, forMarshaling->correlationMaskCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkRenderPassMultiviewCreateInfo(
+ VulkanStream* vkStream,
+ VkRenderPassMultiviewCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pViewMasks, forUnmarshaling->subpassCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pViewMasks, forUnmarshaling->subpassCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pViewOffsets, forUnmarshaling->dependencyCount * sizeof(const int32_t));
+ vkStream->read((int32_t*)forUnmarshaling->pViewOffsets, forUnmarshaling->dependencyCount * sizeof(const int32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->correlationMaskCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pCorrelationMasks, forUnmarshaling->correlationMaskCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCorrelationMasks, forUnmarshaling->correlationMaskCount * sizeof(const uint32_t));
+}
+
+void marshal_VkPhysicalDeviceMultiviewFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMultiviewFeatures* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->multiviewGeometryShader, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->multiviewTessellationShader, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMultiviewFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMultiviewFeatures* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->multiview, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->multiviewGeometryShader, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->multiviewTessellationShader, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceMultiviewProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMultiviewProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceMultiviewProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMultiviewProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewViewCount, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceVariablePointerFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceVariablePointerFeatures* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->variablePointers, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceVariablePointerFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceVariablePointerFeatures* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->variablePointersStorageBuffer, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->variablePointers, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->protectedMemory, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->protectedMemory, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceProtectedMemoryProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->protectedNoFault, sizeof(VkBool32));
+}
+
+void marshal_VkDeviceQueueInfo2(
+ VulkanStream* vkStream,
+ const VkDeviceQueueInfo2* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+}
+
+void unmarshal_VkDeviceQueueInfo2(
+ VulkanStream* vkStream,
+ VkDeviceQueueInfo2* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+}
+
+void marshal_VkProtectedSubmitInfo(
+ VulkanStream* vkStream,
+ const VkProtectedSubmitInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->protectedSubmit, sizeof(VkBool32));
+}
+
+void unmarshal_VkProtectedSubmitInfo(
+ VulkanStream* vkStream,
+ VkProtectedSubmitInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->protectedSubmit, sizeof(VkBool32));
+}
+
+void marshal_VkSamplerYcbcrConversionCreateInfo(
+ VulkanStream* vkStream,
+ const VkSamplerYcbcrConversionCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((VkChromaLocation*)&forMarshaling->xChromaOffset, sizeof(VkChromaLocation));
+ vkStream->write((VkChromaLocation*)&forMarshaling->yChromaOffset, sizeof(VkChromaLocation));
+ vkStream->write((VkFilter*)&forMarshaling->chromaFilter, sizeof(VkFilter));
+ vkStream->write((VkBool32*)&forMarshaling->forceExplicitReconstruction, sizeof(VkBool32));
+}
+
+void unmarshal_VkSamplerYcbcrConversionCreateInfo(
+ VulkanStream* vkStream,
+ VkSamplerYcbcrConversionCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->xChromaOffset, sizeof(VkChromaLocation));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->yChromaOffset, sizeof(VkChromaLocation));
+ vkStream->read((VkFilter*)&forUnmarshaling->chromaFilter, sizeof(VkFilter));
+ vkStream->read((VkBool32*)&forUnmarshaling->forceExplicitReconstruction, sizeof(VkBool32));
+}
+
+void marshal_VkSamplerYcbcrConversionInfo(
+ VulkanStream* vkStream,
+ const VkSamplerYcbcrConversionInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_164;
+ vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_164, 1);
+ vkStream->write((uint64_t*)&cgen_var_164, 1 * 8);
+}
+
+void unmarshal_VkSamplerYcbcrConversionInfo(
+ VulkanStream* vkStream,
+ VkSamplerYcbcrConversionInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_165;
+ vkStream->read((uint64_t*)&cgen_var_165, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_165, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
+}
+
+void marshal_VkBindImagePlaneMemoryInfo(
+ VulkanStream* vkStream,
+ const VkBindImagePlaneMemoryInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+}
+
+void unmarshal_VkBindImagePlaneMemoryInfo(
+ VulkanStream* vkStream,
+ VkBindImagePlaneMemoryInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+}
+
+void marshal_VkImagePlaneMemoryRequirementsInfo(
+ VulkanStream* vkStream,
+ const VkImagePlaneMemoryRequirementsInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+}
+
+void unmarshal_VkImagePlaneMemoryRequirementsInfo(
+ VulkanStream* vkStream,
+ VkImagePlaneMemoryRequirementsInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+}
+
+void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->samplerYcbcrConversion, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->samplerYcbcrConversion, sizeof(VkBool32));
+}
+
+void marshal_VkSamplerYcbcrConversionImageFormatProperties(
+ VulkanStream* vkStream,
+ const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
+ VulkanStream* vkStream,
+ VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
+}
+
+void marshal_VkDescriptorUpdateTemplateEntry(
+ VulkanStream* vkStream,
+ const VkDescriptorUpdateTemplateEntry* forMarshaling)
+{
+ 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));
+ vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
+ uint64_t cgen_var_166 = (uint64_t)forMarshaling->offset;
+ vkStream->putBe64(cgen_var_166);
+ uint64_t cgen_var_167 = (uint64_t)forMarshaling->stride;
+ vkStream->putBe64(cgen_var_167);
+}
+
+void unmarshal_VkDescriptorUpdateTemplateEntry(
+ VulkanStream* vkStream,
+ VkDescriptorUpdateTemplateEntry* forUnmarshaling)
+{
+ 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));
+ vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
+ forUnmarshaling->offset = (size_t)vkStream->getBe64();
+ forUnmarshaling->stride = (size_t)vkStream->getBe64();
+}
+
+void marshal_VkDescriptorUpdateTemplateCreateInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorUpdateTemplateCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDescriptorUpdateTemplateCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorUpdateTemplateCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i)
+ {
+ marshal_VkDescriptorUpdateTemplateEntry(vkStream, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i));
+ }
+ vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
+ uint64_t cgen_var_170;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&forMarshaling->descriptorSetLayout, &cgen_var_170, 1);
+ vkStream->write((uint64_t*)&cgen_var_170, 1 * 8);
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ uint64_t cgen_var_171;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_171, 1);
+ vkStream->write((uint64_t*)&cgen_var_171, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
+ VulkanStream* vkStream,
+ VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDescriptorUpdateTemplateCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorUpdateTemplateCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDescriptorUpdateEntries, forUnmarshaling->descriptorUpdateEntryCount * sizeof(const VkDescriptorUpdateTemplateEntry));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorUpdateEntryCount; ++i)
+ {
+ unmarshal_VkDescriptorUpdateTemplateEntry(vkStream, (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
+ }
+ vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
+ uint64_t cgen_var_172;
+ vkStream->read((uint64_t*)&cgen_var_172, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_172, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ uint64_t cgen_var_173;
+ vkStream->read((uint64_t*)&cgen_var_173, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_173, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
+}
+
+void marshal_VkExternalMemoryProperties(
+ VulkanStream* vkStream,
+ const VkExternalMemoryProperties* forMarshaling)
+{
+ vkStream->write((VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlags));
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void unmarshal_VkExternalMemoryProperties(
+ VulkanStream* vkStream,
+ VkExternalMemoryProperties* forUnmarshaling)
+{
+ vkStream->read((VkExternalMemoryFeatureFlags*)&forUnmarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlags));
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void marshal_VkPhysicalDeviceExternalImageFormatInfo(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void marshal_VkExternalImageFormatProperties(
+ VulkanStream* vkStream,
+ const VkExternalImageFormatProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
+}
+
+void unmarshal_VkExternalImageFormatProperties(
+ VulkanStream* vkStream,
+ VkExternalImageFormatProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
+}
+
+void marshal_VkPhysicalDeviceExternalBufferInfo(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalBufferInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
+ vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void unmarshal_VkPhysicalDeviceExternalBufferInfo(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalBufferInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferCreateFlags));
+ vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void marshal_VkExternalBufferProperties(
+ VulkanStream* vkStream,
+ const VkExternalBufferProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
+}
+
+void unmarshal_VkExternalBufferProperties(
+ VulkanStream* vkStream,
+ VkExternalBufferProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkExternalMemoryProperties(vkStream, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
+}
+
+void marshal_VkPhysicalDeviceIDProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceIDProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((uint32_t*)&forMarshaling->deviceNodeMask, sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->deviceLUIDValid, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceIDProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceIDProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceNodeMask, sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->deviceLUIDValid, sizeof(VkBool32));
+}
+
+void marshal_VkExternalMemoryImageCreateInfo(
+ VulkanStream* vkStream,
+ const VkExternalMemoryImageCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void unmarshal_VkExternalMemoryImageCreateInfo(
+ VulkanStream* vkStream,
+ VkExternalMemoryImageCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void marshal_VkExternalMemoryBufferCreateInfo(
+ VulkanStream* vkStream,
+ const VkExternalMemoryBufferCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void unmarshal_VkExternalMemoryBufferCreateInfo(
+ VulkanStream* vkStream,
+ VkExternalMemoryBufferCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void marshal_VkExportMemoryAllocateInfo(
+ VulkanStream* vkStream,
+ const VkExportMemoryAllocateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void unmarshal_VkExportMemoryAllocateInfo(
+ VulkanStream* vkStream,
+ VkExportMemoryAllocateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+}
+
+void marshal_VkPhysicalDeviceExternalFenceInfo(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalFenceInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+void unmarshal_VkPhysicalDeviceExternalFenceInfo(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalFenceInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+void marshal_VkExternalFenceProperties(
+ VulkanStream* vkStream,
+ const VkExternalFenceProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->write((VkExternalFenceFeatureFlags*)&forMarshaling->externalFenceFeatures, sizeof(VkExternalFenceFeatureFlags));
+}
+
+void unmarshal_VkExternalFenceProperties(
+ VulkanStream* vkStream,
+ VkExternalFenceProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->read((VkExternalFenceFeatureFlags*)&forUnmarshaling->externalFenceFeatures, sizeof(VkExternalFenceFeatureFlags));
+}
+
+void marshal_VkExportFenceCreateInfo(
+ VulkanStream* vkStream,
+ const VkExportFenceCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+}
+
+void unmarshal_VkExportFenceCreateInfo(
+ VulkanStream* vkStream,
+ VkExportFenceCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+}
+
+void marshal_VkExportSemaphoreCreateInfo(
+ VulkanStream* vkStream,
+ const VkExportSemaphoreCreateInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+}
+
+void unmarshal_VkExportSemaphoreCreateInfo(
+ VulkanStream* vkStream,
+ VkExportSemaphoreCreateInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+}
+
+void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+void marshal_VkExternalSemaphoreProperties(
+ VulkanStream* vkStream,
+ const VkExternalSemaphoreProperties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->write((VkExternalSemaphoreFeatureFlags*)&forMarshaling->externalSemaphoreFeatures, sizeof(VkExternalSemaphoreFeatureFlags));
+}
+
+void unmarshal_VkExternalSemaphoreProperties(
+ VulkanStream* vkStream,
+ VkExternalSemaphoreProperties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->read((VkExternalSemaphoreFeatureFlags*)&forUnmarshaling->externalSemaphoreFeatures, sizeof(VkExternalSemaphoreFeatureFlags));
+}
+
+void marshal_VkPhysicalDeviceMaintenance3Properties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMaintenance3Properties* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxPerSetDescriptors, sizeof(uint32_t));
+ vkStream->write((VkDeviceSize*)&forMarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance3Properties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMaintenance3Properties* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerSetDescriptors, sizeof(uint32_t));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkDescriptorSetLayoutSupport(
+ VulkanStream* vkStream,
+ const VkDescriptorSetLayoutSupport* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->supported, sizeof(VkBool32));
+}
+
+void unmarshal_VkDescriptorSetLayoutSupport(
+ VulkanStream* vkStream,
+ VkDescriptorSetLayoutSupport* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->supported, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderDrawParameterFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceShaderDrawParameterFeatures* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceShaderDrawParameterFeatures* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderDrawParameters, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_KHR_surface
+void marshal_VkSurfaceCapabilitiesKHR(
+ VulkanStream* vkStream,
+ const VkSurfaceCapabilitiesKHR* forMarshaling)
+{
+ 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));
+ vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
+ vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+}
+
+void unmarshal_VkSurfaceCapabilitiesKHR(
+ VulkanStream* vkStream,
+ VkSurfaceCapabilitiesKHR* forUnmarshaling)
+{
+ 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));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
+ vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+}
+
+void marshal_VkSurfaceFormatKHR(
+ VulkanStream* vkStream,
+ const VkSurfaceFormatKHR* forMarshaling)
+{
+ vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+ vkStream->write((VkColorSpaceKHR*)&forMarshaling->colorSpace, sizeof(VkColorSpaceKHR));
+}
+
+void unmarshal_VkSurfaceFormatKHR(
+ VulkanStream* vkStream,
+ VkSurfaceFormatKHR* forUnmarshaling)
+{
+ vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+ vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->colorSpace, sizeof(VkColorSpaceKHR));
+}
+
+#endif
+#ifdef VK_KHR_swapchain
+void marshal_VkSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkSwapchainCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
+ uint64_t cgen_var_174;
+ vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_174, 1);
+ vkStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+ 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));
+ vkStream->write((uint32_t*)&forMarshaling->imageArrayLayers, sizeof(uint32_t));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
+ vkStream->write((VkSharingMode*)&forMarshaling->imageSharingMode, sizeof(VkSharingMode));
+ vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_175 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+ vkStream->putBe64(cgen_var_175);
+ if (forMarshaling->pQueueFamilyIndices)
+ {
+ vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ }
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->preTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
+ vkStream->write((VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
+ vkStream->write((VkBool32*)&forMarshaling->clipped, sizeof(VkBool32));
+ uint64_t cgen_var_176;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain, &cgen_var_176, 1);
+ vkStream->write((uint64_t*)&cgen_var_176, 1 * 8);
+}
+
+void unmarshal_VkSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkSwapchainCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
+ uint64_t cgen_var_177;
+ vkStream->read((uint64_t*)&cgen_var_177, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_177, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
+ vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
+ vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
+ unmarshal_VkExtent2D(vkStream, (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));
+ vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndexCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pQueueFamilyIndices)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ }
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->preTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkCompositeAlphaFlagBitsKHR*)&forUnmarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
+ vkStream->read((VkPresentModeKHR*)&forUnmarshaling->presentMode, sizeof(VkPresentModeKHR));
+ vkStream->read((VkBool32*)&forUnmarshaling->clipped, sizeof(VkBool32));
+ uint64_t cgen_var_179;
+ vkStream->read((uint64_t*)&cgen_var_179, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_179, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
+}
+
+void marshal_VkPresentInfoKHR(
+ VulkanStream* vkStream,
+ const VkPresentInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
+ if (forMarshaling->waitSemaphoreCount)
+ {
+ uint64_t* cgen_var_180;
+ vkStream->alloc((void**)&cgen_var_180, forMarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_180, forMarshaling->waitSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_180, forMarshaling->waitSemaphoreCount * 8);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+ if (forMarshaling->swapchainCount)
+ {
+ uint64_t* cgen_var_181;
+ vkStream->alloc((void**)&cgen_var_181, forMarshaling->swapchainCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(forMarshaling->pSwapchains, cgen_var_181, forMarshaling->swapchainCount);
+ vkStream->write((uint64_t*)cgen_var_181, forMarshaling->swapchainCount * 8);
+ }
+ vkStream->write((const uint32_t*)forMarshaling->pImageIndices, forMarshaling->swapchainCount * sizeof(const uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_182 = (uint64_t)(uintptr_t)forMarshaling->pResults;
+ vkStream->putBe64(cgen_var_182);
+ if (forMarshaling->pResults)
+ {
+ vkStream->write((VkResult*)forMarshaling->pResults, forMarshaling->swapchainCount * sizeof(VkResult));
+ }
+}
+
+void unmarshal_VkPresentInfoKHR(
+ VulkanStream* vkStream,
+ VkPresentInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount * sizeof(const VkSemaphore));
+ if (forUnmarshaling->waitSemaphoreCount)
+ {
+ uint64_t* cgen_var_183;
+ vkStream->alloc((void**)&cgen_var_183, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_183, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_183, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount * sizeof(const VkSwapchainKHR));
+ if (forUnmarshaling->swapchainCount)
+ {
+ uint64_t* cgen_var_184;
+ vkStream->alloc((void**)&cgen_var_184, forUnmarshaling->swapchainCount * 8);
+ vkStream->read((uint64_t*)cgen_var_184, forUnmarshaling->swapchainCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_184, (VkSwapchainKHR*)forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount);
+ }
+ vkStream->alloc((void**)&forUnmarshaling->pImageIndices, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pImageIndices, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pResults = (VkResult*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pResults)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pResults, forUnmarshaling->swapchainCount * sizeof(VkResult));
+ vkStream->read((VkResult*)forUnmarshaling->pResults, forUnmarshaling->swapchainCount * sizeof(VkResult));
+ }
+}
+
+void marshal_VkImageSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkImageSwapchainCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_186;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_186, 1);
+ vkStream->write((uint64_t*)&cgen_var_186, 1 * 8);
+}
+
+void unmarshal_VkImageSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkImageSwapchainCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_187;
+ vkStream->read((uint64_t*)&cgen_var_187, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_187, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+}
+
+void marshal_VkBindImageMemorySwapchainInfoKHR(
+ VulkanStream* vkStream,
+ const VkBindImageMemorySwapchainInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_188;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_188, 1);
+ vkStream->write((uint64_t*)&cgen_var_188, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->imageIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkBindImageMemorySwapchainInfoKHR(
+ VulkanStream* vkStream,
+ VkBindImageMemorySwapchainInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_189;
+ vkStream->read((uint64_t*)&cgen_var_189, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_189, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->imageIndex, sizeof(uint32_t));
+}
+
+void marshal_VkAcquireNextImageInfoKHR(
+ VulkanStream* vkStream,
+ const VkAcquireNextImageInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_190;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_190, 1);
+ vkStream->write((uint64_t*)&cgen_var_190, 1 * 8);
+ vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
+ uint64_t cgen_var_191;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_191, 1);
+ vkStream->write((uint64_t*)&cgen_var_191, 1 * 8);
+ uint64_t cgen_var_192;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_192, 1);
+ vkStream->write((uint64_t*)&cgen_var_192, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void unmarshal_VkAcquireNextImageInfoKHR(
+ VulkanStream* vkStream,
+ VkAcquireNextImageInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_193;
+ vkStream->read((uint64_t*)&cgen_var_193, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_193, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
+ uint64_t cgen_var_194;
+ vkStream->read((uint64_t*)&cgen_var_194, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_194, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ uint64_t cgen_var_195;
+ vkStream->read((uint64_t*)&cgen_var_195, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_195, (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void marshal_VkDeviceGroupPresentCapabilitiesKHR(
+ VulkanStream* vkStream,
+ const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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(
+ VulkanStream* vkStream,
+ VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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(
+ VulkanStream* vkStream,
+ const VkDeviceGroupPresentInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+}
+
+void unmarshal_VkDeviceGroupPresentInfoKHR(
+ VulkanStream* vkStream,
+ VkDeviceGroupPresentInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDeviceMasks, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pDeviceMasks, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+ vkStream->read((VkDeviceGroupPresentModeFlagBitsKHR*)&forUnmarshaling->mode, sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
+}
+
+void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+}
+
+void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+}
+
+#endif
+#ifdef VK_KHR_display
+void marshal_VkDisplayPropertiesKHR(
+ VulkanStream* vkStream,
+ const VkDisplayPropertiesKHR* forMarshaling)
+{
+ uint64_t cgen_var_196;
+ vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_196, 1);
+ vkStream->write((uint64_t*)&cgen_var_196, 1 * 8);
+ vkStream->putString(forMarshaling->displayName);
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalDimensions));
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalResolution));
+ vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->write((VkBool32*)&forMarshaling->planeReorderPossible, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->persistentContent, sizeof(VkBool32));
+}
+
+void unmarshal_VkDisplayPropertiesKHR(
+ VulkanStream* vkStream,
+ VkDisplayPropertiesKHR* forUnmarshaling)
+{
+ uint64_t cgen_var_197;
+ vkStream->read((uint64_t*)&cgen_var_197, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_197, (VkDisplayKHR*)&forUnmarshaling->display, 1);
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->displayName);
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
+ vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->read((VkBool32*)&forUnmarshaling->planeReorderPossible, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->persistentContent, sizeof(VkBool32));
+}
+
+void marshal_VkDisplayModeParametersKHR(
+ VulkanStream* vkStream,
+ const VkDisplayModeParametersKHR* forMarshaling)
+{
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->visibleRegion));
+ vkStream->write((uint32_t*)&forMarshaling->refreshRate, sizeof(uint32_t));
+}
+
+void unmarshal_VkDisplayModeParametersKHR(
+ VulkanStream* vkStream,
+ VkDisplayModeParametersKHR* forUnmarshaling)
+{
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->visibleRegion));
+ vkStream->read((uint32_t*)&forUnmarshaling->refreshRate, sizeof(uint32_t));
+}
+
+void marshal_VkDisplayModePropertiesKHR(
+ VulkanStream* vkStream,
+ const VkDisplayModePropertiesKHR* forMarshaling)
+{
+ uint64_t cgen_var_198;
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_198, 1);
+ vkStream->write((uint64_t*)&cgen_var_198, 1 * 8);
+ marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
+}
+
+void unmarshal_VkDisplayModePropertiesKHR(
+ VulkanStream* vkStream,
+ VkDisplayModePropertiesKHR* forUnmarshaling)
+{
+ uint64_t cgen_var_199;
+ vkStream->read((uint64_t*)&cgen_var_199, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_199, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+ unmarshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
+}
+
+void marshal_VkDisplayModeCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkDisplayModeCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
+ marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
+}
+
+void unmarshal_VkDisplayModeCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkDisplayModeCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDisplayModeCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
+ unmarshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
+}
+
+void marshal_VkDisplayPlaneCapabilitiesKHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlaneCapabilitiesKHR* forMarshaling)
+{
+ 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));
+}
+
+void unmarshal_VkDisplayPlaneCapabilitiesKHR(
+ VulkanStream* vkStream,
+ VkDisplayPlaneCapabilitiesKHR* forUnmarshaling)
+{
+ 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));
+}
+
+void marshal_VkDisplayPlanePropertiesKHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlanePropertiesKHR* forMarshaling)
+{
+ uint64_t cgen_var_200;
+ vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay, &cgen_var_200, 1);
+ vkStream->write((uint64_t*)&cgen_var_200, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->currentStackIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkDisplayPlanePropertiesKHR(
+ VulkanStream* vkStream,
+ VkDisplayPlanePropertiesKHR* forUnmarshaling)
+{
+ uint64_t cgen_var_201;
+ vkStream->read((uint64_t*)&cgen_var_201, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_201, (VkDisplayKHR*)&forUnmarshaling->currentDisplay, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->currentStackIndex, sizeof(uint32_t));
+}
+
+void marshal_VkDisplaySurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkDisplaySurfaceCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
+ uint64_t cgen_var_202;
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_202, 1);
+ vkStream->write((uint64_t*)&cgen_var_202, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->planeStackIndex, sizeof(uint32_t));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((float*)&forMarshaling->globalAlpha, sizeof(float));
+ vkStream->write((VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkDisplaySurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkDisplaySurfaceCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
+ uint64_t cgen_var_203;
+ vkStream->read((uint64_t*)&cgen_var_203, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_203, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->planeStackIndex, sizeof(uint32_t));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((float*)&forUnmarshaling->globalAlpha, sizeof(float));
+ vkStream->read((VkDisplayPlaneAlphaFlagBitsKHR*)&forUnmarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->imageExtent));
+}
+
+#endif
+#ifdef VK_KHR_display_swapchain
+void marshal_VkDisplayPresentInfoKHR(
+ VulkanStream* vkStream,
+ const VkDisplayPresentInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->srcRect));
+ marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->dstRect));
+ vkStream->write((VkBool32*)&forMarshaling->persistent, sizeof(VkBool32));
+}
+
+void unmarshal_VkDisplayPresentInfoKHR(
+ VulkanStream* vkStream,
+ VkDisplayPresentInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->srcRect));
+ unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->dstRect));
+ vkStream->read((VkBool32*)&forUnmarshaling->persistent, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_KHR_xlib_surface
+void marshal_VkXlibSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkXlibSurfaceCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_204 = (uint64_t)(uintptr_t)forMarshaling->dpy;
+ vkStream->putBe64(cgen_var_204);
+ if (forMarshaling->dpy)
+ {
+ vkStream->write((Display*)forMarshaling->dpy, sizeof(Display));
+ }
+ vkStream->write((Window*)&forMarshaling->window, sizeof(Window));
+}
+
+void unmarshal_VkXlibSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkXlibSurfaceCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkXlibSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ forUnmarshaling->dpy = (Display*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->dpy)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->dpy, sizeof(Display));
+ vkStream->read((Display*)forUnmarshaling->dpy, sizeof(Display));
+ }
+ vkStream->read((Window*)&forUnmarshaling->window, sizeof(Window));
+}
+
+#endif
+#ifdef VK_KHR_xcb_surface
+void marshal_VkXcbSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkXcbSurfaceCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkXcbSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_206 = (uint64_t)(uintptr_t)forMarshaling->connection;
+ vkStream->putBe64(cgen_var_206);
+ if (forMarshaling->connection)
+ {
+ vkStream->write((xcb_connection_t*)forMarshaling->connection, sizeof(xcb_connection_t));
+ }
+ vkStream->write((xcb_window_t*)&forMarshaling->window, sizeof(xcb_window_t));
+}
+
+void unmarshal_VkXcbSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkXcbSurfaceCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkXcbSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ forUnmarshaling->connection = (xcb_connection_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->connection)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->connection, sizeof(xcb_connection_t));
+ vkStream->read((xcb_connection_t*)forUnmarshaling->connection, sizeof(xcb_connection_t));
+ }
+ vkStream->read((xcb_window_t*)&forUnmarshaling->window, sizeof(xcb_window_t));
+}
+
+#endif
+#ifdef VK_KHR_wayland_surface
+void marshal_VkWaylandSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkWaylandSurfaceCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_208 = (uint64_t)(uintptr_t)forMarshaling->display;
+ vkStream->putBe64(cgen_var_208);
+ if (forMarshaling->display)
+ {
+ vkStream->write((wl_display*)forMarshaling->display, sizeof(wl_display));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_209 = (uint64_t)(uintptr_t)forMarshaling->surface;
+ vkStream->putBe64(cgen_var_209);
+ if (forMarshaling->surface)
+ {
+ vkStream->write((wl_surface*)forMarshaling->surface, sizeof(wl_surface));
+ }
+}
+
+void unmarshal_VkWaylandSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkWaylandSurfaceCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkWaylandSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ forUnmarshaling->display = (wl_display*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->display)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->display, sizeof(wl_display));
+ vkStream->read((wl_display*)forUnmarshaling->display, sizeof(wl_display));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->surface = (wl_surface*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->surface)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->surface, sizeof(wl_surface));
+ vkStream->read((wl_surface*)forUnmarshaling->surface, sizeof(wl_surface));
+ }
+}
+
+#endif
+#ifdef VK_KHR_mir_surface
+void marshal_VkMirSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkMirSurfaceCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkMirSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_212 = (uint64_t)(uintptr_t)forMarshaling->connection;
+ vkStream->putBe64(cgen_var_212);
+ if (forMarshaling->connection)
+ {
+ vkStream->write((MirConnection*)forMarshaling->connection, sizeof(MirConnection));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_213 = (uint64_t)(uintptr_t)forMarshaling->mirSurface;
+ vkStream->putBe64(cgen_var_213);
+ if (forMarshaling->mirSurface)
+ {
+ vkStream->write((MirSurface*)forMarshaling->mirSurface, sizeof(MirSurface));
+ }
+}
+
+void unmarshal_VkMirSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkMirSurfaceCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkMirSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ forUnmarshaling->connection = (MirConnection*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->connection)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->connection, sizeof(MirConnection));
+ vkStream->read((MirConnection*)forUnmarshaling->connection, sizeof(MirConnection));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->mirSurface = (MirSurface*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->mirSurface)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->mirSurface, sizeof(MirSurface));
+ vkStream->read((MirSurface*)forUnmarshaling->mirSurface, sizeof(MirSurface));
+ }
+}
+
+#endif
+#ifdef VK_KHR_android_surface
+void marshal_VkAndroidSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkAndroidSurfaceCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_216 = (uint64_t)(uintptr_t)forMarshaling->window;
+ vkStream->putBe64(cgen_var_216);
+ if (forMarshaling->window)
+ {
+ vkStream->write((ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
+ }
+}
+
+void unmarshal_VkAndroidSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkAndroidSurfaceCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkAndroidSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
+ // WARNING PTR CHECK
+ forUnmarshaling->window = (ANativeWindow*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->window)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->window, sizeof(ANativeWindow));
+ vkStream->read((ANativeWindow*)forUnmarshaling->window, sizeof(ANativeWindow));
+ }
+}
+
+#endif
+#ifdef VK_KHR_win32_surface
+void marshal_VkWin32SurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkWin32SurfaceCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkWin32SurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWin32SurfaceCreateFlagsKHR));
+ vkStream->write((HINSTANCE*)&forMarshaling->hinstance, sizeof(HINSTANCE));
+ vkStream->write((HWND*)&forMarshaling->hwnd, sizeof(HWND));
+}
+
+void unmarshal_VkWin32SurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkWin32SurfaceCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkWin32SurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkWin32SurfaceCreateFlagsKHR));
+ vkStream->read((HINSTANCE*)&forUnmarshaling->hinstance, sizeof(HINSTANCE));
+ vkStream->read((HWND*)&forUnmarshaling->hwnd, sizeof(HWND));
+}
+
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void marshal_VkImportMemoryWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportMemoryWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
+ vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkImportMemoryWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkImportMemoryWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
+ vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkExportMemoryWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkExportMemoryWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_218 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_218);
+ if (forMarshaling->pAttributes)
+ {
+ vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+ vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
+ vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkExportMemoryWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkExportMemoryWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pAttributes)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+ vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
+ vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkMemoryWin32HandlePropertiesKHR(
+ VulkanStream* vkStream,
+ const VkMemoryWin32HandlePropertiesKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryWin32HandlePropertiesKHR(
+ VulkanStream* vkStream,
+ VkMemoryWin32HandlePropertiesKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkMemoryGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkMemoryGetWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_220;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_220, 1);
+ vkStream->write((uint64_t*)&cgen_var_220, 1 * 8);
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void unmarshal_VkMemoryGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkMemoryGetWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_221;
+ vkStream->read((uint64_t*)&cgen_var_221, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_221, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_external_memory_fd
+void marshal_VkImportMemoryFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportMemoryFdInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((int*)&forMarshaling->fd, sizeof(int));
+}
+
+void unmarshal_VkImportMemoryFdInfoKHR(
+ VulkanStream* vkStream,
+ VkImportMemoryFdInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
+}
+
+void marshal_VkMemoryFdPropertiesKHR(
+ VulkanStream* vkStream,
+ const VkMemoryFdPropertiesKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryFdPropertiesKHR(
+ VulkanStream* vkStream,
+ VkMemoryFdPropertiesKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkMemoryGetFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkMemoryGetFdInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_222;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_222, 1);
+ vkStream->write((uint64_t*)&cgen_var_222, 1 * 8);
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+void unmarshal_VkMemoryGetFdInfoKHR(
+ VulkanStream* vkStream,
+ VkMemoryGetFdInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_223;
+ vkStream->read((uint64_t*)&cgen_var_223, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_223, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ VulkanStream* vkStream,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
+ if (forMarshaling->acquireCount)
+ {
+ uint64_t* cgen_var_224;
+ vkStream->alloc((void**)&cgen_var_224, forMarshaling->acquireCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_224, forMarshaling->acquireCount);
+ vkStream->write((uint64_t*)cgen_var_224, forMarshaling->acquireCount * 8);
+ }
+ vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeouts, forMarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
+ if (forMarshaling->releaseCount)
+ {
+ uint64_t* cgen_var_225;
+ vkStream->alloc((void**)&cgen_var_225, forMarshaling->releaseCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_225, forMarshaling->releaseCount);
+ vkStream->write((uint64_t*)cgen_var_225, forMarshaling->releaseCount * 8);
+ }
+ vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
+}
+
+void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ VulkanStream* vkStream,
+ VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount * sizeof(const VkDeviceMemory));
+ if (forUnmarshaling->acquireCount)
+ {
+ uint64_t* cgen_var_226;
+ vkStream->alloc((void**)&cgen_var_226, forUnmarshaling->acquireCount * 8);
+ vkStream->read((uint64_t*)cgen_var_226, forUnmarshaling->acquireCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_226, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+ }
+ vkStream->alloc((void**)&forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAcquireTimeouts, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeouts, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount * sizeof(const VkDeviceMemory));
+ if (forUnmarshaling->releaseCount)
+ {
+ uint64_t* cgen_var_227;
+ vkStream->alloc((void**)&cgen_var_227, forUnmarshaling->releaseCount * 8);
+ vkStream->read((uint64_t*)cgen_var_227, forUnmarshaling->releaseCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_227, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+ }
+ vkStream->alloc((void**)&forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void marshal_VkImportSemaphoreWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_228;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_228, 1);
+ vkStream->write((uint64_t*)&cgen_var_228, 1 * 8);
+ vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
+ vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_229;
+ vkStream->read((uint64_t*)&cgen_var_229, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_229, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
+ vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkExportSemaphoreWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_230 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_230);
+ if (forMarshaling->pAttributes)
+ {
+ vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+ vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
+ vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pAttributes)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+ vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
+ vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkD3D12FenceSubmitInfoKHR(
+ VulkanStream* vkStream,
+ const VkD3D12FenceSubmitInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_232 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
+ vkStream->putBe64(cgen_var_232);
+ if (forMarshaling->pWaitSemaphoreValues)
+ {
+ vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues, forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_233 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
+ vkStream->putBe64(cgen_var_233);
+ if (forMarshaling->pSignalSemaphoreValues)
+ {
+ vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ }
+}
+
+void unmarshal_VkD3D12FenceSubmitInfoKHR(
+ VulkanStream* vkStream,
+ VkD3D12FenceSubmitInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pWaitSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pWaitSemaphoreValues)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreValues, forUnmarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pWaitSemaphoreValues, forUnmarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pSignalSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pSignalSemaphoreValues)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pSignalSemaphoreValues, forUnmarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pSignalSemaphoreValues, forUnmarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ }
+}
+
+void marshal_VkSemaphoreGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_236;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_236, 1);
+ vkStream->write((uint64_t*)&cgen_var_236, 1 * 8);
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_237;
+ vkStream->read((uint64_t*)&cgen_var_237, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_237, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void marshal_VkImportSemaphoreFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportSemaphoreFdInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_238;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_238, 1);
+ vkStream->write((uint64_t*)&cgen_var_238, 1 * 8);
+ vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((int*)&forMarshaling->fd, sizeof(int));
+}
+
+void unmarshal_VkImportSemaphoreFdInfoKHR(
+ VulkanStream* vkStream,
+ VkImportSemaphoreFdInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_239;
+ vkStream->read((uint64_t*)&cgen_var_239, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_239, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
+}
+
+void marshal_VkSemaphoreGetFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkSemaphoreGetFdInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_240;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_240, 1);
+ vkStream->write((uint64_t*)&cgen_var_240, 1 * 8);
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+void unmarshal_VkSemaphoreGetFdInfoKHR(
+ VulkanStream* vkStream,
+ VkSemaphoreGetFdInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_241;
+ vkStream->read((uint64_t*)&cgen_var_241, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_241, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_push_descriptor
+void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ VulkanStream* vkStream,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ VulkanStream* vkStream,
+ VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPushDescriptors, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void marshal_VkRectLayerKHR(
+ VulkanStream* vkStream,
+ const VkRectLayerKHR* forMarshaling)
+{
+ marshal_VkOffset2D(vkStream, (VkOffset2D*)(&forMarshaling->offset));
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->extent));
+ vkStream->write((uint32_t*)&forMarshaling->layer, sizeof(uint32_t));
+}
+
+void unmarshal_VkRectLayerKHR(
+ VulkanStream* vkStream,
+ VkRectLayerKHR* forUnmarshaling)
+{
+ unmarshal_VkOffset2D(vkStream, (VkOffset2D*)(&forUnmarshaling->offset));
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->extent));
+ vkStream->read((uint32_t*)&forUnmarshaling->layer, sizeof(uint32_t));
+}
+
+void marshal_VkPresentRegionKHR(
+ VulkanStream* vkStream,
+ const VkPresentRegionKHR* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_242 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
+ vkStream->putBe64(cgen_var_242);
+ if (forMarshaling->pRectangles)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
+ {
+ marshal_VkRectLayerKHR(vkStream, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i));
+ }
+ }
+}
+
+void unmarshal_VkPresentRegionKHR(
+ VulkanStream* vkStream,
+ VkPresentRegionKHR* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->rectangleCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pRectangles = (const VkRectLayerKHR*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pRectangles)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pRectangles, forUnmarshaling->rectangleCount * sizeof(const VkRectLayerKHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->rectangleCount; ++i)
+ {
+ unmarshal_VkRectLayerKHR(vkStream, (VkRectLayerKHR*)(forUnmarshaling->pRectangles + i));
+ }
+ }
+}
+
+void marshal_VkPresentRegionsKHR(
+ VulkanStream* vkStream,
+ const VkPresentRegionsKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_244 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
+ vkStream->putBe64(cgen_var_244);
+ if (forMarshaling->pRegions)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
+ {
+ marshal_VkPresentRegionKHR(vkStream, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i));
+ }
+ }
+}
+
+void unmarshal_VkPresentRegionsKHR(
+ VulkanStream* vkStream,
+ VkPresentRegionsKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pRegions = (const VkPresentRegionKHR*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pRegions)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pRegions, forUnmarshaling->swapchainCount * sizeof(const VkPresentRegionKHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i)
+ {
+ unmarshal_VkPresentRegionKHR(vkStream, (VkPresentRegionKHR*)(forUnmarshaling->pRegions + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+void marshal_VkAttachmentDescription2KHR(
+ VulkanStream* vkStream,
+ const VkAttachmentDescription2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+ vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+ vkStream->write((VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
+ vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+ vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
+ vkStream->write((VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkAttachmentDescription2KHR(
+ VulkanStream* vkStream,
+ VkAttachmentDescription2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+ vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+ vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
+ vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+ vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
+ vkStream->read((VkImageLayout*)&forUnmarshaling->finalLayout, sizeof(VkImageLayout));
+}
+
+void marshal_VkAttachmentReference2KHR(
+ VulkanStream* vkStream,
+ const VkAttachmentReference2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+}
+
+void unmarshal_VkAttachmentReference2KHR(
+ VulkanStream* vkStream,
+ VkAttachmentReference2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+}
+
+void marshal_VkSubpassDescription2KHR(
+ VulkanStream* vkStream,
+ const VkSubpassDescription2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
+ {
+ marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pInputAttachments + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
+ {
+ marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pColorAttachments + i));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+ vkStream->putBe64(cgen_var_246);
+ if (forMarshaling->pResolveAttachments)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
+ {
+ marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pResolveAttachments + i));
+ }
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_247 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+ vkStream->putBe64(cgen_var_247);
+ if (forMarshaling->pDepthStencilAttachment)
+ {
+ marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pDepthStencilAttachment));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments, forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkSubpassDescription2KHR(
+ VulkanStream* vkStream,
+ VkSubpassDescription2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pInputAttachments, forUnmarshaling->inputAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i)
+ {
+ unmarshal_VkAttachmentReference2KHR(vkStream, (VkAttachmentReference2KHR*)(forUnmarshaling->pInputAttachments + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pColorAttachments, forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
+ {
+ unmarshal_VkAttachmentReference2KHR(vkStream, (VkAttachmentReference2KHR*)(forUnmarshaling->pColorAttachments + i));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pResolveAttachments = (const VkAttachmentReference2KHR*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pResolveAttachments)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pResolveAttachments, forUnmarshaling->colorAttachmentCount * sizeof(const VkAttachmentReference2KHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
+ {
+ unmarshal_VkAttachmentReference2KHR(vkStream, (VkAttachmentReference2KHR*)(forUnmarshaling->pResolveAttachments + i));
+ }
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pDepthStencilAttachment = (const VkAttachmentReference2KHR*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDepthStencilAttachment)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pDepthStencilAttachment, sizeof(const VkAttachmentReference2KHR));
+ unmarshal_VkAttachmentReference2KHR(vkStream, (VkAttachmentReference2KHR*)(forUnmarshaling->pDepthStencilAttachment));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->preserveAttachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+}
+
+void marshal_VkSubpassDependency2KHR(
+ VulkanStream* vkStream,
+ const VkSubpassDependency2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
+ vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
+ vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+ vkStream->write((int32_t*)&forMarshaling->viewOffset, sizeof(int32_t));
+}
+
+void unmarshal_VkSubpassDependency2KHR(
+ VulkanStream* vkStream,
+ VkSubpassDependency2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->srcSubpass, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->dstSubpass, sizeof(uint32_t));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
+ vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
+ vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+ vkStream->read((int32_t*)&forUnmarshaling->viewOffset, sizeof(int32_t));
+}
+
+void marshal_VkRenderPassCreateInfo2KHR(
+ VulkanStream* vkStream,
+ const VkRenderPassCreateInfo2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
+ {
+ marshal_VkAttachmentDescription2KHR(vkStream, (const VkAttachmentDescription2KHR*)(forMarshaling->pAttachments + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
+ {
+ marshal_VkSubpassDescription2KHR(vkStream, (const VkSubpassDescription2KHR*)(forMarshaling->pSubpasses + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
+ {
+ marshal_VkSubpassDependency2KHR(vkStream, (const VkSubpassDependency2KHR*)(forMarshaling->pDependencies + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->correlatedViewMaskCount, sizeof(uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pCorrelatedViewMasks, forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkRenderPassCreateInfo2KHR(
+ VulkanStream* vkStream,
+ VkRenderPassCreateInfo2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags, sizeof(VkRenderPassCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount * sizeof(const VkAttachmentDescription2KHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
+ {
+ unmarshal_VkAttachmentDescription2KHR(vkStream, (VkAttachmentDescription2KHR*)(forUnmarshaling->pAttachments + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSubpasses, forUnmarshaling->subpassCount * sizeof(const VkSubpassDescription2KHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i)
+ {
+ unmarshal_VkSubpassDescription2KHR(vkStream, (VkSubpassDescription2KHR*)(forUnmarshaling->pSubpasses + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDependencies, forUnmarshaling->dependencyCount * sizeof(const VkSubpassDependency2KHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i)
+ {
+ unmarshal_VkSubpassDependency2KHR(vkStream, (VkSubpassDependency2KHR*)(forUnmarshaling->pDependencies + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->correlatedViewMaskCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pCorrelatedViewMasks, forUnmarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCorrelatedViewMasks, forUnmarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+}
+
+void marshal_VkSubpassBeginInfoKHR(
+ VulkanStream* vkStream,
+ const VkSubpassBeginInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkSubpassContents*)&forMarshaling->contents, sizeof(VkSubpassContents));
+}
+
+void unmarshal_VkSubpassBeginInfoKHR(
+ VulkanStream* vkStream,
+ VkSubpassBeginInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkSubpassContents*)&forUnmarshaling->contents, sizeof(VkSubpassContents));
+}
+
+void marshal_VkSubpassEndInfoKHR(
+ VulkanStream* vkStream,
+ const VkSubpassEndInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+}
+
+void unmarshal_VkSubpassEndInfoKHR(
+ VulkanStream* vkStream,
+ VkSubpassEndInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+}
+
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
+ VulkanStream* vkStream,
+ const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
+}
+
+void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
+ VulkanStream* vkStream,
+ VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
+}
+
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void marshal_VkImportFenceWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportFenceWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_250;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_250, 1);
+ vkStream->write((uint64_t*)&cgen_var_250, 1 * 8);
+ vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
+ vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkImportFenceWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkImportFenceWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_251;
+ vkStream->read((uint64_t*)&cgen_var_251, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_251, (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
+ vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkExportFenceWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkExportFenceWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_252 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_252);
+ if (forMarshaling->pAttributes)
+ {
+ vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+ vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
+ vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
+}
+
+void unmarshal_VkExportFenceWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkExportFenceWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pAttributes)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+ vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
+ vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
+}
+
+void marshal_VkFenceGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkFenceGetWin32HandleInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_254;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_254, 1);
+ vkStream->write((uint64_t*)&cgen_var_254, 1 * 8);
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+void unmarshal_VkFenceGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkFenceGetWin32HandleInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_255;
+ vkStream->read((uint64_t*)&cgen_var_255, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_255, (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_external_fence_fd
+void marshal_VkImportFenceFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportFenceFdInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_256;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_256, 1);
+ vkStream->write((uint64_t*)&cgen_var_256, 1 * 8);
+ vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->write((int*)&forMarshaling->fd, sizeof(int));
+}
+
+void unmarshal_VkImportFenceFdInfoKHR(
+ VulkanStream* vkStream,
+ VkImportFenceFdInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_257;
+ vkStream->read((uint64_t*)&cgen_var_257, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_257, (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
+}
+
+void marshal_VkFenceGetFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkFenceGetFdInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_258;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_258, 1);
+ vkStream->write((uint64_t*)&cgen_var_258, 1 * 8);
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+void unmarshal_VkFenceGetFdInfoKHR(
+ VulkanStream* vkStream,
+ VkFenceGetFdInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_259;
+ vkStream->read((uint64_t*)&cgen_var_259, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_259, (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+}
+
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_260;
+ vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_260, 1);
+ vkStream->write((uint64_t*)&cgen_var_260, 1 * 8);
+}
+
+void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_261;
+ vkStream->read((uint64_t*)&cgen_var_261, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_261, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+}
+
+void marshal_VkSurfaceCapabilities2KHR(
+ VulkanStream* vkStream,
+ const VkSurfaceCapabilities2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities));
+}
+
+void unmarshal_VkSurfaceCapabilities2KHR(
+ VulkanStream* vkStream,
+ VkSurfaceCapabilities2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkSurfaceCapabilitiesKHR(vkStream, (VkSurfaceCapabilitiesKHR*)(&forUnmarshaling->surfaceCapabilities));
+}
+
+void marshal_VkSurfaceFormat2KHR(
+ VulkanStream* vkStream,
+ const VkSurfaceFormat2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat));
+}
+
+void unmarshal_VkSurfaceFormat2KHR(
+ VulkanStream* vkStream,
+ VkSurfaceFormat2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkSurfaceFormatKHR(vkStream, (VkSurfaceFormatKHR*)(&forUnmarshaling->surfaceFormat));
+}
+
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void marshal_VkDisplayProperties2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayProperties2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties));
+}
+
+void unmarshal_VkDisplayProperties2KHR(
+ VulkanStream* vkStream,
+ VkDisplayProperties2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkDisplayPropertiesKHR(vkStream, (VkDisplayPropertiesKHR*)(&forUnmarshaling->displayProperties));
+}
+
+void marshal_VkDisplayPlaneProperties2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlaneProperties2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties));
+}
+
+void unmarshal_VkDisplayPlaneProperties2KHR(
+ VulkanStream* vkStream,
+ VkDisplayPlaneProperties2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkDisplayPlanePropertiesKHR(vkStream, (VkDisplayPlanePropertiesKHR*)(&forUnmarshaling->displayPlaneProperties));
+}
+
+void marshal_VkDisplayModeProperties2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayModeProperties2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties));
+}
+
+void unmarshal_VkDisplayModeProperties2KHR(
+ VulkanStream* vkStream,
+ VkDisplayModeProperties2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkDisplayModePropertiesKHR(vkStream, (VkDisplayModePropertiesKHR*)(&forUnmarshaling->displayModeProperties));
+}
+
+void marshal_VkDisplayPlaneInfo2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlaneInfo2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_262;
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_262, 1);
+ vkStream->write((uint64_t*)&cgen_var_262, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkDisplayPlaneInfo2KHR(
+ VulkanStream* vkStream,
+ VkDisplayPlaneInfo2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_263;
+ vkStream->read((uint64_t*)&cgen_var_263, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_263, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
+}
+
+void marshal_VkDisplayPlaneCapabilities2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlaneCapabilities2KHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities));
+}
+
+void unmarshal_VkDisplayPlaneCapabilities2KHR(
+ VulkanStream* vkStream,
+ VkDisplayPlaneCapabilities2KHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkDisplayPlaneCapabilitiesKHR(vkStream, (VkDisplayPlaneCapabilitiesKHR*)(&forUnmarshaling->capabilities));
+}
+
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+void marshal_VkImageFormatListCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkImageFormatListCreateInfoKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
+ vkStream->write((const VkFormat*)forMarshaling->pViewFormats, forMarshaling->viewFormatCount * sizeof(const VkFormat));
+}
+
+void unmarshal_VkImageFormatListCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkImageFormatListCreateInfoKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->viewFormatCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pViewFormats, forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
+ vkStream->read((VkFormat*)forUnmarshaling->pViewFormats, forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
+}
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+void marshal_VkPhysicalDevice8BitStorageFeaturesKHR(
+ VulkanStream* vkStream,
+ const VkPhysicalDevice8BitStorageFeaturesKHR* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->storagePushConstant8, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR(
+ VulkanStream* vkStream,
+ VkPhysicalDevice8BitStorageFeaturesKHR* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant8, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void marshal_VkNativeBufferANDROID(
+ VulkanStream* vkStream,
+ const VkNativeBufferANDROID* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_264 = (uint64_t)(uintptr_t)forMarshaling->handle;
+ vkStream->putBe64(cgen_var_264);
+ if (forMarshaling->handle)
+ {
+ vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
+ }
+ vkStream->write((int*)&forMarshaling->stride, sizeof(int));
+ vkStream->write((int*)&forMarshaling->format, sizeof(int));
+ vkStream->write((int*)&forMarshaling->usage, sizeof(int));
+ vkStream->write((uint64_t*)&forMarshaling->consumer, sizeof(uint64_t));
+ vkStream->write((uint64_t*)&forMarshaling->producer, sizeof(uint64_t));
+}
+
+void unmarshal_VkNativeBufferANDROID(
+ VulkanStream* vkStream,
+ VkNativeBufferANDROID* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->handle = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->handle)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->handle, sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->handle, sizeof(const uint32_t));
+ }
+ vkStream->read((int*)&forUnmarshaling->stride, sizeof(int));
+ vkStream->read((int*)&forUnmarshaling->format, sizeof(int));
+ vkStream->read((int*)&forUnmarshaling->usage, sizeof(int));
+ vkStream->read((uint64_t*)&forUnmarshaling->consumer, sizeof(uint64_t));
+ vkStream->read((uint64_t*)&forUnmarshaling->producer, sizeof(uint64_t));
+}
+
+#endif
+#ifdef VK_EXT_debug_report
+void marshal_VkDebugReportCallbackCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugReportCallbackCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
+ uint64_t cgen_var_266 = (uint64_t)forMarshaling->pfnCallback;
+ vkStream->putBe64(cgen_var_266);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_267 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_267);
+ if (forMarshaling->pUserData)
+ {
+ vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
+ }
+}
+
+void unmarshal_VkDebugReportCallbackCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugReportCallbackCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDebugReportFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugReportFlagsEXT));
+ forUnmarshaling->pfnCallback = (PFN_vkDebugReportCallbackEXT)vkStream->getBe64();
+ // WARNING PTR CHECK
+ forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pUserData)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
+ vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+ VulkanStream* vkStream,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
+}
+
+void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+ VulkanStream* vkStream,
+ VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkRasterizationOrderAMD*)&forUnmarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
+}
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void marshal_VkDebugMarkerObjectNameInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugMarkerObjectNameInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+ vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
+ vkStream->putString(forMarshaling->pObjectName);
+}
+
+void unmarshal_VkDebugMarkerObjectNameInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugMarkerObjectNameInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+ vkStream->read((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+}
+
+void marshal_VkDebugMarkerObjectTagInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugMarkerObjectTagInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ uint64_t cgen_var_270 = (uint64_t)forMarshaling->tagSize;
+ vkStream->putBe64(cgen_var_270);
+ vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkDebugMarkerObjectTagInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugMarkerObjectTagInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ forUnmarshaling->tagSize = (size_t)vkStream->getBe64();
+ vkStream->alloc((void**)&forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void marshal_VkDebugMarkerMarkerInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugMarkerMarkerInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->putString(forMarshaling->pMarkerName);
+ vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
+}
+
+void unmarshal_VkDebugMarkerMarkerInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugMarkerMarkerInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pMarkerName);
+ vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
+}
+
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void marshal_VkDedicatedAllocationImageCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkDedicatedAllocationImageCreateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
+ VulkanStream* vkStream,
+ VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
+}
+
+void marshal_VkDedicatedAllocationBufferCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->dedicatedAllocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
+ VulkanStream* vkStream,
+ VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->dedicatedAllocation, sizeof(VkBool32));
+}
+
+void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+ VulkanStream* vkStream,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_272;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_272, 1);
+ vkStream->write((uint64_t*)&cgen_var_272, 1 * 8);
+ uint64_t cgen_var_273;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_273, 1);
+ vkStream->write((uint64_t*)&cgen_var_273, 1 * 8);
+}
+
+void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+ VulkanStream* vkStream,
+ VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_274;
+ vkStream->read((uint64_t*)&cgen_var_274, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_274, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_275;
+ vkStream->read((uint64_t*)&cgen_var_275, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_275, (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void marshal_VkTextureLODGatherFormatPropertiesAMD(
+ VulkanStream* vkStream,
+ const VkTextureLODGatherFormatPropertiesAMD* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
+}
+
+void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
+ VulkanStream* vkStream,
+ VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->supportsTextureGatherLODBiasAMD, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_AMD_shader_info
+void marshal_VkShaderResourceUsageAMD(
+ VulkanStream* vkStream,
+ const VkShaderResourceUsageAMD* forMarshaling)
+{
+ 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));
+ uint64_t cgen_var_276 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
+ vkStream->putBe64(cgen_var_276);
+ uint64_t cgen_var_277 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
+ vkStream->putBe64(cgen_var_277);
+}
+
+void unmarshal_VkShaderResourceUsageAMD(
+ VulkanStream* vkStream,
+ VkShaderResourceUsageAMD* forUnmarshaling)
+{
+ 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));
+ forUnmarshaling->ldsUsageSizeInBytes = (size_t)vkStream->getBe64();
+ forUnmarshaling->scratchMemUsageInBytes = (size_t)vkStream->getBe64();
+}
+
+void marshal_VkShaderStatisticsInfoAMD(
+ VulkanStream* vkStream,
+ const VkShaderStatisticsInfoAMD* forMarshaling)
+{
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
+ marshal_VkShaderResourceUsageAMD(vkStream, (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));
+ vkStream->write((uint32_t*)&forMarshaling->numAvailableSgprs, sizeof(uint32_t));
+ vkStream->write((uint32_t*)forMarshaling->computeWorkGroupSize, 3 * sizeof(uint32_t));
+}
+
+void unmarshal_VkShaderStatisticsInfoAMD(
+ VulkanStream* vkStream,
+ VkShaderStatisticsInfoAMD* forUnmarshaling)
+{
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
+ unmarshal_VkShaderResourceUsageAMD(vkStream, (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));
+ vkStream->read((uint32_t*)&forUnmarshaling->numAvailableSgprs, sizeof(uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->computeWorkGroupSize, 3 * sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void marshal_VkExternalImageFormatPropertiesNV(
+ VulkanStream* vkStream,
+ const VkExternalImageFormatPropertiesNV* forMarshaling)
+{
+ marshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
+ vkStream->write((VkExternalMemoryFeatureFlagsNV*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlagsNV));
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+void unmarshal_VkExternalImageFormatPropertiesNV(
+ VulkanStream* vkStream,
+ VkExternalImageFormatPropertiesNV* forUnmarshaling)
+{
+ unmarshal_VkImageFormatProperties(vkStream, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
+ vkStream->read((VkExternalMemoryFeatureFlagsNV*)&forUnmarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlagsNV));
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+#endif
+#ifdef VK_NV_external_memory
+void marshal_VkExternalMemoryImageCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkExternalMemoryImageCreateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+void unmarshal_VkExternalMemoryImageCreateInfoNV(
+ VulkanStream* vkStream,
+ VkExternalMemoryImageCreateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+void marshal_VkExportMemoryAllocateInfoNV(
+ VulkanStream* vkStream,
+ const VkExportMemoryAllocateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+void unmarshal_VkExportMemoryAllocateInfoNV(
+ VulkanStream* vkStream,
+ VkExportMemoryAllocateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+}
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void marshal_VkImportMemoryWin32HandleInfoNV(
+ VulkanStream* vkStream,
+ const VkImportMemoryWin32HandleInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
+}
+
+void unmarshal_VkImportMemoryWin32HandleInfoNV(
+ VulkanStream* vkStream,
+ VkImportMemoryWin32HandleInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
+}
+
+void marshal_VkExportMemoryWin32HandleInfoNV(
+ VulkanStream* vkStream,
+ const VkExportMemoryWin32HandleInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_280 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_280);
+ if (forMarshaling->pAttributes)
+ {
+ vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+ vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
+}
+
+void unmarshal_VkExportMemoryWin32HandleInfoNV(
+ VulkanStream* vkStream,
+ VkExportMemoryWin32HandleInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pAttributes)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ }
+ vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
+}
+
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ VulkanStream* vkStream,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
+ if (forMarshaling->acquireCount)
+ {
+ uint64_t* cgen_var_282;
+ vkStream->alloc((void**)&cgen_var_282, forMarshaling->acquireCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_282, forMarshaling->acquireCount);
+ vkStream->write((uint64_t*)cgen_var_282, forMarshaling->acquireCount * 8);
+ }
+ vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds, forMarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
+ if (forMarshaling->releaseCount)
+ {
+ uint64_t* cgen_var_283;
+ vkStream->alloc((void**)&cgen_var_283, forMarshaling->releaseCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_283, forMarshaling->releaseCount);
+ vkStream->write((uint64_t*)cgen_var_283, forMarshaling->releaseCount * 8);
+ }
+ vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
+}
+
+void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ VulkanStream* vkStream,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount * sizeof(const VkDeviceMemory));
+ if (forUnmarshaling->acquireCount)
+ {
+ uint64_t* cgen_var_284;
+ vkStream->alloc((void**)&cgen_var_284, forUnmarshaling->acquireCount * 8);
+ vkStream->read((uint64_t*)cgen_var_284, forUnmarshaling->acquireCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_284, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+ }
+ vkStream->alloc((void**)&forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAcquireTimeoutMilliseconds, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeoutMilliseconds, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount * sizeof(const VkDeviceMemory));
+ if (forUnmarshaling->releaseCount)
+ {
+ uint64_t* cgen_var_285;
+ vkStream->alloc((void**)&cgen_var_285, forUnmarshaling->releaseCount * 8);
+ vkStream->read((uint64_t*)cgen_var_285, forUnmarshaling->releaseCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_285, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+ }
+ vkStream->alloc((void**)&forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+}
+
+#endif
+#ifdef VK_EXT_validation_flags
+void marshal_VkValidationFlagsEXT(
+ VulkanStream* vkStream,
+ const VkValidationFlagsEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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(
+ VulkanStream* vkStream,
+ VkValidationFlagsEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->disabledValidationCheckCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDisabledValidationChecks, forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+ vkStream->read((VkValidationCheckEXT*)forUnmarshaling->pDisabledValidationChecks, forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+}
+
+#endif
+#ifdef VK_NN_vi_surface
+void marshal_VkViSurfaceCreateInfoNN(
+ VulkanStream* vkStream,
+ const VkViSurfaceCreateInfoNN* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_286 = (uint64_t)(uintptr_t)forMarshaling->window;
+ vkStream->putBe64(cgen_var_286);
+ if (forMarshaling->window)
+ {
+ vkStream->write((void*)forMarshaling->window, sizeof(uint8_t));
+ }
+}
+
+void unmarshal_VkViSurfaceCreateInfoNN(
+ VulkanStream* vkStream,
+ VkViSurfaceCreateInfoNN* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkViSurfaceCreateFlagsNN*)&forUnmarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
+ // WARNING PTR CHECK
+ forUnmarshaling->window = (void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->window)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->window, sizeof(uint8_t));
+ vkStream->read((void*)forUnmarshaling->window, sizeof(uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void marshal_VkConditionalRenderingBeginInfoEXT(
+ VulkanStream* vkStream,
+ const VkConditionalRenderingBeginInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_288;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_288, 1);
+ vkStream->write((uint64_t*)&cgen_var_288, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->write((VkConditionalRenderingFlagsEXT*)&forMarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
+}
+
+void unmarshal_VkConditionalRenderingBeginInfoEXT(
+ VulkanStream* vkStream,
+ VkConditionalRenderingBeginInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_289;
+ vkStream->read((uint64_t*)&cgen_var_289, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_289, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->read((VkConditionalRenderingFlagsEXT*)&forUnmarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
+}
+
+void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->conditionalRendering, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->inheritedConditionalRendering, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->conditionalRendering, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->inheritedConditionalRendering, sizeof(VkBool32));
+}
+
+void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ VulkanStream* vkStream,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->conditionalRenderingEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ VulkanStream* vkStream,
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->conditionalRenderingEnable, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_NVX_device_generated_commands
+void marshal_VkDeviceGeneratedCommandsFeaturesNVX(
+ VulkanStream* vkStream,
+ const VkDeviceGeneratedCommandsFeaturesNVX* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->computeBindingPointSupport, sizeof(VkBool32));
+}
+
+void unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(
+ VulkanStream* vkStream,
+ VkDeviceGeneratedCommandsFeaturesNVX* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->computeBindingPointSupport, sizeof(VkBool32));
+}
+
+void marshal_VkDeviceGeneratedCommandsLimitsNVX(
+ VulkanStream* vkStream,
+ const VkDeviceGeneratedCommandsLimitsNVX* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsLayoutTokenCount, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxObjectEntryCounts, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minSequenceCountBufferOffsetAlignment, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minSequenceIndexBufferOffsetAlignment, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minCommandsTokenBufferOffsetAlignment, sizeof(uint32_t));
+}
+
+void unmarshal_VkDeviceGeneratedCommandsLimitsNVX(
+ VulkanStream* vkStream,
+ VkDeviceGeneratedCommandsLimitsNVX* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsLayoutTokenCount, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxObjectEntryCounts, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minSequenceCountBufferOffsetAlignment, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minSequenceIndexBufferOffsetAlignment, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minCommandsTokenBufferOffsetAlignment, sizeof(uint32_t));
+}
+
+void marshal_VkIndirectCommandsTokenNVX(
+ VulkanStream* vkStream,
+ const VkIndirectCommandsTokenNVX* forMarshaling)
+{
+ vkStream->write((VkIndirectCommandsTokenTypeNVX*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
+ uint64_t cgen_var_290;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_290, 1);
+ vkStream->write((uint64_t*)&cgen_var_290, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkIndirectCommandsTokenNVX(
+ VulkanStream* vkStream,
+ VkIndirectCommandsTokenNVX* forUnmarshaling)
+{
+ vkStream->read((VkIndirectCommandsTokenTypeNVX*)&forUnmarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
+ uint64_t cgen_var_291;
+ vkStream->read((uint64_t*)&cgen_var_291, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_291, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+}
+
+void marshal_VkIndirectCommandsLayoutTokenNVX(
+ VulkanStream* vkStream,
+ const VkIndirectCommandsLayoutTokenNVX* forMarshaling)
+{
+ vkStream->write((VkIndirectCommandsTokenTypeNVX*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
+ vkStream->write((uint32_t*)&forMarshaling->bindingUnit, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->dynamicCount, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
+}
+
+void unmarshal_VkIndirectCommandsLayoutTokenNVX(
+ VulkanStream* vkStream,
+ VkIndirectCommandsLayoutTokenNVX* forUnmarshaling)
+{
+ vkStream->read((VkIndirectCommandsTokenTypeNVX*)&forUnmarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
+ vkStream->read((uint32_t*)&forUnmarshaling->bindingUnit, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->dynamicCount, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->divisor, sizeof(uint32_t));
+}
+
+void marshal_VkIndirectCommandsLayoutCreateInfoNVX(
+ VulkanStream* vkStream,
+ const VkIndirectCommandsLayoutCreateInfoNVX* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->write((VkIndirectCommandsLayoutUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkIndirectCommandsLayoutUsageFlagsNVX));
+ vkStream->write((uint32_t*)&forMarshaling->tokenCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i)
+ {
+ marshal_VkIndirectCommandsLayoutTokenNVX(vkStream, (const VkIndirectCommandsLayoutTokenNVX*)(forMarshaling->pTokens + i));
+ }
+}
+
+void unmarshal_VkIndirectCommandsLayoutCreateInfoNVX(
+ VulkanStream* vkStream,
+ VkIndirectCommandsLayoutCreateInfoNVX* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->read((VkIndirectCommandsLayoutUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkIndirectCommandsLayoutUsageFlagsNVX));
+ vkStream->read((uint32_t*)&forUnmarshaling->tokenCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pTokens, forUnmarshaling->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNVX));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->tokenCount; ++i)
+ {
+ unmarshal_VkIndirectCommandsLayoutTokenNVX(vkStream, (VkIndirectCommandsLayoutTokenNVX*)(forUnmarshaling->pTokens + i));
+ }
+}
+
+void marshal_VkCmdProcessCommandsInfoNVX(
+ VulkanStream* vkStream,
+ const VkCmdProcessCommandsInfoNVX* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_292;
+ vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_292, 1);
+ vkStream->write((uint64_t*)&cgen_var_292, 1 * 8);
+ uint64_t cgen_var_293;
+ vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_293, 1);
+ vkStream->write((uint64_t*)&cgen_var_293, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->indirectCommandsTokenCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->indirectCommandsTokenCount; ++i)
+ {
+ marshal_VkIndirectCommandsTokenNVX(vkStream, (const VkIndirectCommandsTokenNVX*)(forMarshaling->pIndirectCommandsTokens + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
+ uint64_t cgen_var_294;
+ vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->targetCommandBuffer, &cgen_var_294, 1);
+ vkStream->write((uint64_t*)&cgen_var_294, 1 * 8);
+ uint64_t cgen_var_295;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer, &cgen_var_295, 1);
+ vkStream->write((uint64_t*)&cgen_var_295, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_296;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer, &cgen_var_296, 1);
+ vkStream->write((uint64_t*)&cgen_var_296, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkCmdProcessCommandsInfoNVX(
+ VulkanStream* vkStream,
+ VkCmdProcessCommandsInfoNVX* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_297;
+ vkStream->read((uint64_t*)&cgen_var_297, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_297, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
+ uint64_t cgen_var_298;
+ vkStream->read((uint64_t*)&cgen_var_298, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_298, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->indirectCommandsTokenCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pIndirectCommandsTokens, forUnmarshaling->indirectCommandsTokenCount * sizeof(const VkIndirectCommandsTokenNVX));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->indirectCommandsTokenCount; ++i)
+ {
+ unmarshal_VkIndirectCommandsTokenNVX(vkStream, (VkIndirectCommandsTokenNVX*)(forUnmarshaling->pIndirectCommandsTokens + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
+ uint64_t cgen_var_299;
+ vkStream->read((uint64_t*)&cgen_var_299, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(&cgen_var_299, (VkCommandBuffer*)&forUnmarshaling->targetCommandBuffer, 1);
+ uint64_t cgen_var_300;
+ vkStream->read((uint64_t*)&cgen_var_300, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_300, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
+ uint64_t cgen_var_301;
+ vkStream->read((uint64_t*)&cgen_var_301, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_301, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
+}
+
+void marshal_VkCmdReserveSpaceForCommandsInfoNVX(
+ VulkanStream* vkStream,
+ const VkCmdReserveSpaceForCommandsInfoNVX* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_302;
+ vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_302, 1);
+ vkStream->write((uint64_t*)&cgen_var_302, 1 * 8);
+ uint64_t cgen_var_303;
+ vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_303, 1);
+ vkStream->write((uint64_t*)&cgen_var_303, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkCmdReserveSpaceForCommandsInfoNVX(
+ VulkanStream* vkStream,
+ VkCmdReserveSpaceForCommandsInfoNVX* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_304;
+ vkStream->read((uint64_t*)&cgen_var_304, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_304, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
+ uint64_t cgen_var_305;
+ vkStream->read((uint64_t*)&cgen_var_305, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_305, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
+}
+
+void marshal_VkObjectTableCreateInfoNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableCreateInfoNVX* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
+ vkStream->write((const VkObjectEntryTypeNVX*)forMarshaling->pObjectEntryTypes, forMarshaling->objectCount * sizeof(const VkObjectEntryTypeNVX));
+ vkStream->write((const uint32_t*)forMarshaling->pObjectEntryCounts, forMarshaling->objectCount * sizeof(const uint32_t));
+ vkStream->write((const VkObjectEntryUsageFlagsNVX*)forMarshaling->pObjectEntryUsageFlags, forMarshaling->objectCount * sizeof(const VkObjectEntryUsageFlagsNVX));
+ vkStream->write((uint32_t*)&forMarshaling->maxUniformBuffersPerDescriptor, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxStorageBuffersPerDescriptor, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxStorageImagesPerDescriptor, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxSampledImagesPerDescriptor, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPipelineLayouts, sizeof(uint32_t));
+}
+
+void unmarshal_VkObjectTableCreateInfoNVX(
+ VulkanStream* vkStream,
+ VkObjectTableCreateInfoNVX* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->objectCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pObjectEntryTypes, forUnmarshaling->objectCount * sizeof(const VkObjectEntryTypeNVX));
+ vkStream->read((VkObjectEntryTypeNVX*)forUnmarshaling->pObjectEntryTypes, forUnmarshaling->objectCount * sizeof(const VkObjectEntryTypeNVX));
+ vkStream->alloc((void**)&forUnmarshaling->pObjectEntryCounts, forUnmarshaling->objectCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pObjectEntryCounts, forUnmarshaling->objectCount * sizeof(const uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pObjectEntryUsageFlags, forUnmarshaling->objectCount * sizeof(const VkObjectEntryUsageFlagsNVX));
+ vkStream->read((VkObjectEntryUsageFlagsNVX*)forUnmarshaling->pObjectEntryUsageFlags, forUnmarshaling->objectCount * sizeof(const VkObjectEntryUsageFlagsNVX));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxUniformBuffersPerDescriptor, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxStorageBuffersPerDescriptor, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxStorageImagesPerDescriptor, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxSampledImagesPerDescriptor, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineLayouts, sizeof(uint32_t));
+}
+
+void marshal_VkObjectTableEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableEntryNVX* forMarshaling)
+{
+ vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+}
+
+void unmarshal_VkObjectTableEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTableEntryNVX* forUnmarshaling)
+{
+ vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+}
+
+void marshal_VkObjectTablePipelineEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTablePipelineEntryNVX* forMarshaling)
+{
+ vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_306;
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_306, 1);
+ vkStream->write((uint64_t*)&cgen_var_306, 1 * 8);
+}
+
+void unmarshal_VkObjectTablePipelineEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTablePipelineEntryNVX* forUnmarshaling)
+{
+ vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_307;
+ vkStream->read((uint64_t*)&cgen_var_307, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_307, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+}
+
+void marshal_VkObjectTableDescriptorSetEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableDescriptorSetEntryNVX* forMarshaling)
+{
+ vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_308;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_308, 1);
+ vkStream->write((uint64_t*)&cgen_var_308, 1 * 8);
+ uint64_t cgen_var_309;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->descriptorSet, &cgen_var_309, 1);
+ vkStream->write((uint64_t*)&cgen_var_309, 1 * 8);
+}
+
+void unmarshal_VkObjectTableDescriptorSetEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTableDescriptorSetEntryNVX* forUnmarshaling)
+{
+ vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_310;
+ vkStream->read((uint64_t*)&cgen_var_310, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_310, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ uint64_t cgen_var_311;
+ vkStream->read((uint64_t*)&cgen_var_311, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_311, (VkDescriptorSet*)&forUnmarshaling->descriptorSet, 1);
+}
+
+void marshal_VkObjectTableVertexBufferEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableVertexBufferEntryNVX* forMarshaling)
+{
+ vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_312;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_312, 1);
+ vkStream->write((uint64_t*)&cgen_var_312, 1 * 8);
+}
+
+void unmarshal_VkObjectTableVertexBufferEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTableVertexBufferEntryNVX* forUnmarshaling)
+{
+ vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_313;
+ vkStream->read((uint64_t*)&cgen_var_313, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_313, (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+void marshal_VkObjectTableIndexBufferEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableIndexBufferEntryNVX* forMarshaling)
+{
+ vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_314;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_314, 1);
+ vkStream->write((uint64_t*)&cgen_var_314, 1 * 8);
+ vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
+}
+
+void unmarshal_VkObjectTableIndexBufferEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTableIndexBufferEntryNVX* forUnmarshaling)
+{
+ vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_315;
+ vkStream->read((uint64_t*)&cgen_var_315, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_315, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
+}
+
+void marshal_VkObjectTablePushConstantEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTablePushConstantEntryNVX* forMarshaling)
+{
+ vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_316;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_316, 1);
+ vkStream->write((uint64_t*)&cgen_var_316, 1 * 8);
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+}
+
+void unmarshal_VkObjectTablePushConstantEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTablePushConstantEntryNVX* forUnmarshaling)
+{
+ vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
+ vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
+ uint64_t cgen_var_317;
+ vkStream->read((uint64_t*)&cgen_var_317, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_317, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+}
+
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void marshal_VkViewportWScalingNV(
+ VulkanStream* vkStream,
+ const VkViewportWScalingNV* forMarshaling)
+{
+ vkStream->write((float*)&forMarshaling->xcoeff, sizeof(float));
+ vkStream->write((float*)&forMarshaling->ycoeff, sizeof(float));
+}
+
+void unmarshal_VkViewportWScalingNV(
+ VulkanStream* vkStream,
+ VkViewportWScalingNV* forUnmarshaling)
+{
+ vkStream->read((float*)&forUnmarshaling->xcoeff, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->ycoeff, sizeof(float));
+}
+
+void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_318 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
+ vkStream->putBe64(cgen_var_318);
+ if (forMarshaling->pViewportWScalings)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
+ {
+ marshal_VkViewportWScalingNV(vkStream, (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i));
+ }
+ }
+}
+
+void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
+ VulkanStream* vkStream,
+ VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->viewportWScalingEnable, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pViewportWScalings = (const VkViewportWScalingNV*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pViewportWScalings)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pViewportWScalings, forUnmarshaling->viewportCount * sizeof(const VkViewportWScalingNV));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
+ {
+ unmarshal_VkViewportWScalingNV(vkStream, (VkViewportWScalingNV*)(forUnmarshaling->pViewportWScalings + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+void marshal_VkSurfaceCapabilities2EXT(
+ VulkanStream* vkStream,
+ const VkSurfaceCapabilities2EXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
+ vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+ vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->supportedSurfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+}
+
+void unmarshal_VkSurfaceCapabilities2EXT(
+ VulkanStream* vkStream,
+ VkSurfaceCapabilities2EXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
+ vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+ vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->supportedSurfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+}
+
+#endif
+#ifdef VK_EXT_display_control
+void marshal_VkDisplayPowerInfoEXT(
+ VulkanStream* vkStream,
+ const VkDisplayPowerInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDisplayPowerStateEXT*)&forMarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
+}
+
+void unmarshal_VkDisplayPowerInfoEXT(
+ VulkanStream* vkStream,
+ VkDisplayPowerInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDisplayPowerStateEXT*)&forUnmarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
+}
+
+void marshal_VkDeviceEventInfoEXT(
+ VulkanStream* vkStream,
+ const VkDeviceEventInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
+}
+
+void unmarshal_VkDeviceEventInfoEXT(
+ VulkanStream* vkStream,
+ VkDeviceEventInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDeviceEventTypeEXT*)&forUnmarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
+}
+
+void marshal_VkDisplayEventInfoEXT(
+ VulkanStream* vkStream,
+ const VkDisplayEventInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDisplayEventTypeEXT*)&forMarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
+}
+
+void unmarshal_VkDisplayEventInfoEXT(
+ VulkanStream* vkStream,
+ VkDisplayEventInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDisplayEventTypeEXT*)&forUnmarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
+}
+
+void marshal_VkSwapchainCounterCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkSwapchainCounterCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+}
+
+void unmarshal_VkSwapchainCounterCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkSwapchainCounterCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+}
+
+#endif
+#ifdef VK_GOOGLE_display_timing
+void marshal_VkRefreshCycleDurationGOOGLE(
+ VulkanStream* vkStream,
+ const VkRefreshCycleDurationGOOGLE* forMarshaling)
+{
+ vkStream->write((uint64_t*)&forMarshaling->refreshDuration, sizeof(uint64_t));
+}
+
+void unmarshal_VkRefreshCycleDurationGOOGLE(
+ VulkanStream* vkStream,
+ VkRefreshCycleDurationGOOGLE* forUnmarshaling)
+{
+ vkStream->read((uint64_t*)&forUnmarshaling->refreshDuration, sizeof(uint64_t));
+}
+
+void marshal_VkPastPresentationTimingGOOGLE(
+ VulkanStream* vkStream,
+ const VkPastPresentationTimingGOOGLE* forMarshaling)
+{
+ 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));
+ vkStream->write((uint64_t*)&forMarshaling->earliestPresentTime, sizeof(uint64_t));
+ vkStream->write((uint64_t*)&forMarshaling->presentMargin, sizeof(uint64_t));
+}
+
+void unmarshal_VkPastPresentationTimingGOOGLE(
+ VulkanStream* vkStream,
+ VkPastPresentationTimingGOOGLE* forUnmarshaling)
+{
+ 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));
+ vkStream->read((uint64_t*)&forUnmarshaling->earliestPresentTime, sizeof(uint64_t));
+ vkStream->read((uint64_t*)&forUnmarshaling->presentMargin, sizeof(uint64_t));
+}
+
+void marshal_VkPresentTimeGOOGLE(
+ VulkanStream* vkStream,
+ const VkPresentTimeGOOGLE* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
+ vkStream->write((uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
+}
+
+void unmarshal_VkPresentTimeGOOGLE(
+ VulkanStream* vkStream,
+ VkPresentTimeGOOGLE* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->presentID, sizeof(uint32_t));
+ vkStream->read((uint64_t*)&forUnmarshaling->desiredPresentTime, sizeof(uint64_t));
+}
+
+void marshal_VkPresentTimesInfoGOOGLE(
+ VulkanStream* vkStream,
+ const VkPresentTimesInfoGOOGLE* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_320 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
+ vkStream->putBe64(cgen_var_320);
+ if (forMarshaling->pTimes)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
+ {
+ marshal_VkPresentTimeGOOGLE(vkStream, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i));
+ }
+ }
+}
+
+void unmarshal_VkPresentTimesInfoGOOGLE(
+ VulkanStream* vkStream,
+ VkPresentTimesInfoGOOGLE* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pTimes = (const VkPresentTimeGOOGLE*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pTimes)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pTimes, forUnmarshaling->swapchainCount * sizeof(const VkPresentTimeGOOGLE));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i)
+ {
+ unmarshal_VkPresentTimeGOOGLE(vkStream, (VkPresentTimeGOOGLE*)(forUnmarshaling->pTimes + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->perViewPositionAllComponents, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->perViewPositionAllComponents, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void marshal_VkViewportSwizzleNV(
+ VulkanStream* vkStream,
+ const VkViewportSwizzleNV* forMarshaling)
+{
+ vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->x, sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->y, sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->z, sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->w, sizeof(VkViewportCoordinateSwizzleNV));
+}
+
+void unmarshal_VkViewportSwizzleNV(
+ VulkanStream* vkStream,
+ VkViewportSwizzleNV* forUnmarshaling)
+{
+ vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->x, sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->y, sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->z, sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->w, sizeof(VkViewportCoordinateSwizzleNV));
+}
+
+void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
+ vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_322 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
+ vkStream->putBe64(cgen_var_322);
+ if (forMarshaling->pViewportSwizzles)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
+ {
+ marshal_VkViewportSwizzleNV(vkStream, (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
+ }
+ }
+}
+
+void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+ VulkanStream* vkStream,
+ VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
+ vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pViewportSwizzles = (const VkViewportSwizzleNV*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pViewportSwizzles)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pViewportSwizzles, forUnmarshaling->viewportCount * sizeof(const VkViewportSwizzleNV));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
+ {
+ unmarshal_VkViewportSwizzleNV(vkStream, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxDiscardRectangles, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDiscardRectangles, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_324 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
+ vkStream->putBe64(cgen_var_324);
+ if (forMarshaling->pDiscardRectangles)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
+ {
+ marshal_VkRect2D(vkStream, (const VkRect2D*)(forMarshaling->pDiscardRectangles + i));
+ }
+ }
+}
+
+void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ // WARNING PTR CHECK
+ forUnmarshaling->pDiscardRectangles = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDiscardRectangles)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pDiscardRectangles, forUnmarshaling->discardRectangleCount * sizeof(const VkRect2D));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->discardRectangleCount; ++i)
+ {
+ unmarshal_VkRect2D(vkStream, (VkRect2D*)(forUnmarshaling->pDiscardRectangles + i));
+ }
+ }
+}
+
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((float*)&forMarshaling->primitiveOverestimationSize, sizeof(float));
+ vkStream->write((float*)&forMarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
+ vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSizeGranularity, sizeof(float));
+ vkStream->write((VkBool32*)&forMarshaling->primitiveUnderestimation, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->conservativePointAndLineRasterization, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->degenerateLinesRasterized, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fullyCoveredFragmentShaderInputVariable, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->conservativeRasterizationPostDepthCoverage, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((float*)&forUnmarshaling->primitiveOverestimationSize, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSizeGranularity, sizeof(float));
+ vkStream->read((VkBool32*)&forUnmarshaling->primitiveUnderestimation, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->conservativePointAndLineRasterization, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->degenerateLinesRasterized, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fullyCoveredFragmentShaderInputVariable, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->conservativeRasterizationPostDepthCoverage, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
+ vkStream->write((VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode, sizeof(VkConservativeRasterizationModeEXT));
+ vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSize, sizeof(float));
+}
+
+void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
+ vkStream->read((VkConservativeRasterizationModeEXT*)&forUnmarshaling->conservativeRasterizationMode, sizeof(VkConservativeRasterizationModeEXT));
+ vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSize, sizeof(float));
+}
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void marshal_VkXYColorEXT(
+ VulkanStream* vkStream,
+ const VkXYColorEXT* forMarshaling)
+{
+ vkStream->write((float*)&forMarshaling->x, sizeof(float));
+ vkStream->write((float*)&forMarshaling->y, sizeof(float));
+}
+
+void unmarshal_VkXYColorEXT(
+ VulkanStream* vkStream,
+ VkXYColorEXT* forUnmarshaling)
+{
+ vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
+}
+
+void marshal_VkHdrMetadataEXT(
+ VulkanStream* vkStream,
+ const VkHdrMetadataEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, 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));
+ vkStream->write((float*)&forMarshaling->maxLuminance, sizeof(float));
+ vkStream->write((float*)&forMarshaling->minLuminance, sizeof(float));
+ vkStream->write((float*)&forMarshaling->maxContentLightLevel, sizeof(float));
+ vkStream->write((float*)&forMarshaling->maxFrameAverageLightLevel, sizeof(float));
+}
+
+void unmarshal_VkHdrMetadataEXT(
+ VulkanStream* vkStream,
+ VkHdrMetadataEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, 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));
+ vkStream->read((float*)&forUnmarshaling->maxLuminance, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->minLuminance, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->maxContentLightLevel, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->maxFrameAverageLightLevel, sizeof(float));
+}
+
+#endif
+#ifdef VK_MVK_ios_surface
+void marshal_VkIOSSurfaceCreateInfoMVK(
+ VulkanStream* vkStream,
+ const VkIOSSurfaceCreateInfoMVK* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_326 = (uint64_t)(uintptr_t)forMarshaling->pView;
+ vkStream->putBe64(cgen_var_326);
+ if (forMarshaling->pView)
+ {
+ vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
+ }
+}
+
+void unmarshal_VkIOSSurfaceCreateInfoMVK(
+ VulkanStream* vkStream,
+ VkIOSSurfaceCreateInfoMVK* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkIOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
+ // WARNING PTR CHECK
+ forUnmarshaling->pView = (const void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pView)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pView, sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pView, sizeof(const uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_MVK_macos_surface
+void marshal_VkMacOSSurfaceCreateInfoMVK(
+ VulkanStream* vkStream,
+ const VkMacOSSurfaceCreateInfoMVK* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_328 = (uint64_t)(uintptr_t)forMarshaling->pView;
+ vkStream->putBe64(cgen_var_328);
+ if (forMarshaling->pView)
+ {
+ vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
+ }
+}
+
+void unmarshal_VkMacOSSurfaceCreateInfoMVK(
+ VulkanStream* vkStream,
+ VkMacOSSurfaceCreateInfoMVK* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkMacOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
+ // WARNING PTR CHECK
+ forUnmarshaling->pView = (const void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pView)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pView, sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pView, sizeof(const uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void marshal_VkDebugUtilsObjectNameInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsObjectNameInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
+ vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
+ vkStream->putString(forMarshaling->pObjectName);
+}
+
+void unmarshal_VkDebugUtilsObjectNameInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsObjectNameInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
+ vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+}
+
+void marshal_VkDebugUtilsObjectTagInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsObjectTagInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ uint64_t cgen_var_330 = (uint64_t)forMarshaling->tagSize;
+ vkStream->putBe64(cgen_var_330);
+ vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkDebugUtilsObjectTagInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsObjectTagInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ forUnmarshaling->tagSize = (size_t)vkStream->getBe64();
+ vkStream->alloc((void**)&forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void marshal_VkDebugUtilsLabelEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsLabelEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->putString(forMarshaling->pLabelName);
+ vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
+}
+
+void unmarshal_VkDebugUtilsLabelEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsLabelEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pLabelName);
+ vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
+}
+
+void marshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+ vkStream->putString(forMarshaling->pMessageIdName);
+ vkStream->write((int32_t*)&forMarshaling->messageIdNumber, sizeof(int32_t));
+ vkStream->putString(forMarshaling->pMessage);
+ vkStream->write((uint32_t*)&forMarshaling->queueLabelCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_332 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
+ vkStream->putBe64(cgen_var_332);
+ if (forMarshaling->pQueueLabels)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
+ {
+ marshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
+ }
+ }
+ vkStream->write((uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_333 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
+ vkStream->putBe64(cgen_var_333);
+ if (forMarshaling->pCmdBufLabels)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
+ {
+ marshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
+ }
+ }
+ vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_334 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
+ vkStream->putBe64(cgen_var_334);
+ if (forMarshaling->pObjects)
+ {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
+ {
+ marshal_VkDebugUtilsObjectNameInfoEXT(vkStream, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
+ }
+ }
+}
+
+void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
+ vkStream->read((int32_t*)&forUnmarshaling->messageIdNumber, sizeof(int32_t));
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessage);
+ vkStream->read((uint32_t*)&forUnmarshaling->queueLabelCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pQueueLabels = (VkDebugUtilsLabelEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pQueueLabels)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pQueueLabels, forUnmarshaling->queueLabelCount * sizeof(VkDebugUtilsLabelEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i)
+ {
+ unmarshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
+ }
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->cmdBufLabelCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pCmdBufLabels = (VkDebugUtilsLabelEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pCmdBufLabels)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels, forUnmarshaling->cmdBufLabelCount * sizeof(VkDebugUtilsLabelEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i)
+ {
+ unmarshal_VkDebugUtilsLabelEXT(vkStream, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
+ }
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->objectCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pObjects = (VkDebugUtilsObjectNameInfoEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pObjects)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pObjects, forUnmarshaling->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i)
+ {
+ unmarshal_VkDebugUtilsObjectNameInfoEXT(vkStream, (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
+ }
+ }
+}
+
+void marshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+ vkStream->write((VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+ vkStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ uint64_t cgen_var_338 = (uint64_t)forMarshaling->pfnUserCallback;
+ vkStream->putBe64(cgen_var_338);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_339 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_339);
+ if (forMarshaling->pUserData)
+ {
+ vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
+ }
+}
+
+void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDebugUtilsMessengerCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+ vkStream->read((VkDebugUtilsMessageSeverityFlagsEXT*)&forUnmarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+ vkStream->read((VkDebugUtilsMessageTypeFlagsEXT*)&forUnmarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ forUnmarshaling->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)vkStream->getBe64();
+ // WARNING PTR CHECK
+ forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pUserData)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
+ vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
+ }
+}
+
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void marshal_VkAndroidHardwareBufferUsageANDROID(
+ VulkanStream* vkStream,
+ const VkAndroidHardwareBufferUsageANDROID* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint64_t*)&forMarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
+}
+
+void unmarshal_VkAndroidHardwareBufferUsageANDROID(
+ VulkanStream* vkStream,
+ VkAndroidHardwareBufferUsageANDROID* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint64_t*)&forUnmarshaling->androidHardwareBufferUsage, sizeof(uint64_t));
+}
+
+void marshal_VkAndroidHardwareBufferPropertiesANDROID(
+ VulkanStream* vkStream,
+ const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDeviceSize*)&forMarshaling->allocationSize, sizeof(VkDeviceSize));
+ vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
+ VulkanStream* vkStream,
+ VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->allocationSize, sizeof(VkDeviceSize));
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ VulkanStream* vkStream,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
+ vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
+ vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+}
+
+void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ VulkanStream* vkStream,
+ VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+}
+
+void marshal_VkImportAndroidHardwareBufferInfoANDROID(
+ VulkanStream* vkStream,
+ const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((AHardwareBuffer*)forMarshaling->buffer, sizeof(AHardwareBuffer));
+}
+
+void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
+ VulkanStream* vkStream,
+ VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->alloc((void**)&forUnmarshaling->buffer, sizeof(AHardwareBuffer));
+ vkStream->read((AHardwareBuffer*)forUnmarshaling->buffer, sizeof(AHardwareBuffer));
+}
+
+void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ VulkanStream* vkStream,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_342;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_342, 1);
+ vkStream->write((uint64_t*)&cgen_var_342, 1 * 8);
+}
+
+void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ VulkanStream* vkStream,
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_343;
+ vkStream->read((uint64_t*)&cgen_var_343, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_343, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+}
+
+void marshal_VkExternalFormatANDROID(
+ VulkanStream* vkStream,
+ const VkExternalFormatANDROID* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
+}
+
+void unmarshal_VkExternalFormatANDROID(
+ VulkanStream* vkStream,
+ VkExternalFormatANDROID* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
+}
+
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void marshal_VkSamplerReductionModeCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkSamplerReductionModeCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkSamplerReductionModeEXT*)&forMarshaling->reductionMode, sizeof(VkSamplerReductionModeEXT));
+}
+
+void unmarshal_VkSamplerReductionModeCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkSamplerReductionModeCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkSamplerReductionModeEXT*)&forUnmarshaling->reductionMode, sizeof(VkSamplerReductionModeEXT));
+}
+
+void marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void marshal_VkSampleLocationEXT(
+ VulkanStream* vkStream,
+ const VkSampleLocationEXT* forMarshaling)
+{
+ vkStream->write((float*)&forMarshaling->x, sizeof(float));
+ vkStream->write((float*)&forMarshaling->y, sizeof(float));
+}
+
+void unmarshal_VkSampleLocationEXT(
+ VulkanStream* vkStream,
+ VkSampleLocationEXT* forUnmarshaling)
+{
+ vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
+}
+
+void marshal_VkSampleLocationsInfoEXT(
+ VulkanStream* vkStream,
+ const VkSampleLocationsInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->sampleLocationsPerPixel, sizeof(VkSampleCountFlagBits));
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->sampleLocationGridSize));
+ vkStream->write((uint32_t*)&forMarshaling->sampleLocationsCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationsCount; ++i)
+ {
+ marshal_VkSampleLocationEXT(vkStream, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i));
+ }
+}
+
+void unmarshal_VkSampleLocationsInfoEXT(
+ VulkanStream* vkStream,
+ VkSampleLocationsInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->sampleLocationsPerPixel, sizeof(VkSampleCountFlagBits));
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->sampleLocationGridSize));
+ vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationsCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pSampleLocations, forUnmarshaling->sampleLocationsCount * sizeof(const VkSampleLocationEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationsCount; ++i)
+ {
+ unmarshal_VkSampleLocationEXT(vkStream, (VkSampleLocationEXT*)(forUnmarshaling->pSampleLocations + i));
+ }
+}
+
+void marshal_VkAttachmentSampleLocationsEXT(
+ VulkanStream* vkStream,
+ const VkAttachmentSampleLocationsEXT* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->attachmentIndex, sizeof(uint32_t));
+ marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+}
+
+void unmarshal_VkAttachmentSampleLocationsEXT(
+ VulkanStream* vkStream,
+ VkAttachmentSampleLocationsEXT* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->attachmentIndex, sizeof(uint32_t));
+ unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+}
+
+void marshal_VkSubpassSampleLocationsEXT(
+ VulkanStream* vkStream,
+ const VkSubpassSampleLocationsEXT* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->subpassIndex, sizeof(uint32_t));
+ marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+}
+
+void unmarshal_VkSubpassSampleLocationsEXT(
+ VulkanStream* vkStream,
+ VkSubpassSampleLocationsEXT* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->subpassIndex, sizeof(uint32_t));
+ unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+}
+
+void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
+ VulkanStream* vkStream,
+ const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->attachmentInitialSampleLocationsCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentInitialSampleLocationsCount; ++i)
+ {
+ marshal_VkAttachmentSampleLocationsEXT(vkStream, (const VkAttachmentSampleLocationsEXT*)(forMarshaling->pAttachmentInitialSampleLocations + i));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->postSubpassSampleLocationsCount; ++i)
+ {
+ marshal_VkSubpassSampleLocationsEXT(vkStream, (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i));
+ }
+}
+
+void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
+ VulkanStream* vkStream,
+ VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->attachmentInitialSampleLocationsCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pAttachmentInitialSampleLocations, forUnmarshaling->attachmentInitialSampleLocationsCount * sizeof(const VkAttachmentSampleLocationsEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentInitialSampleLocationsCount; ++i)
+ {
+ unmarshal_VkAttachmentSampleLocationsEXT(vkStream, (VkAttachmentSampleLocationsEXT*)(forUnmarshaling->pAttachmentInitialSampleLocations + i));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pPostSubpassSampleLocations, forUnmarshaling->postSubpassSampleLocationsCount * sizeof(const VkSubpassSampleLocationsEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->postSubpassSampleLocationsCount; ++i)
+ {
+ unmarshal_VkSubpassSampleLocationsEXT(vkStream, (VkSubpassSampleLocationsEXT*)(forUnmarshaling->pPostSubpassSampleLocations + i));
+ }
+}
+
+void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->sampleLocationsEnable, sizeof(VkBool32));
+ marshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+}
+
+void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->sampleLocationsEnable, sizeof(VkBool32));
+ unmarshal_VkSampleLocationsInfoEXT(vkStream, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+}
+
+void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleLocationSampleCounts, sizeof(VkSampleCountFlags));
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
+ vkStream->write((float*)forMarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
+ vkStream->write((uint32_t*)&forMarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->variableSampleLocations, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleLocationSampleCounts, sizeof(VkSampleCountFlags));
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
+ vkStream->read((float*)forUnmarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
+ vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->variableSampleLocations, sizeof(VkBool32));
+}
+
+void marshal_VkMultisamplePropertiesEXT(
+ VulkanStream* vkStream,
+ const VkMultisamplePropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
+}
+
+void unmarshal_VkMultisamplePropertiesEXT(
+ VulkanStream* vkStream,
+ VkMultisamplePropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
+}
+
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCoherentOperations, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedSrcColor, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedDstColor, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->advancedBlendAllOperations, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedSrcColor, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedDstColor, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendAllOperations, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->srcPremultiplied, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->dstPremultiplied, sizeof(VkBool32));
+ vkStream->write((VkBlendOverlapEXT*)&forMarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
+}
+
+void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->srcPremultiplied, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->dstPremultiplied, sizeof(VkBool32));
+ vkStream->read((VkBlendOverlapEXT*)&forUnmarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
+}
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+}
+
+void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
+ VulkanStream* vkStream,
+ VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+}
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineCoverageModulationStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
+ vkStream->write((VkCoverageModulationModeNV*)&forMarshaling->coverageModulationMode, sizeof(VkCoverageModulationModeNV));
+ vkStream->write((VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->coverageModulationTableCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_344 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
+ vkStream->putBe64(cgen_var_344);
+ if (forMarshaling->pCoverageModulationTable)
+ {
+ vkStream->write((const float*)forMarshaling->pCoverageModulationTable, forMarshaling->coverageModulationTableCount * sizeof(const float));
+ }
+}
+
+void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
+ VulkanStream* vkStream,
+ VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineCoverageModulationStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
+ vkStream->read((VkCoverageModulationModeNV*)&forUnmarshaling->coverageModulationMode, sizeof(VkCoverageModulationModeNV));
+ vkStream->read((VkBool32*)&forUnmarshaling->coverageModulationTableEnable, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->coverageModulationTableCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pCoverageModulationTable = (const float*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pCoverageModulationTable)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pCoverageModulationTable, forUnmarshaling->coverageModulationTableCount * sizeof(const float));
+ vkStream->read((float*)forUnmarshaling->pCoverageModulationTable, forUnmarshaling->coverageModulationTableCount * sizeof(const float));
+ }
+}
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void marshal_VkValidationCacheCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkValidationCacheCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
+ uint64_t cgen_var_346 = (uint64_t)forMarshaling->initialDataSize;
+ vkStream->putBe64(cgen_var_346);
+ vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkValidationCacheCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkValidationCacheCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkValidationCacheCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
+ forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
+ vkStream->alloc((void**)&forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+}
+
+void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ uint64_t cgen_var_348;
+ vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_348, 1);
+ vkStream->write((uint64_t*)&cgen_var_348, 1 * 8);
+}
+
+void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ uint64_t cgen_var_349;
+ vkStream->read((uint64_t*)&cgen_var_349, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_349, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
+}
+
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
+ vkStream->write((const VkDescriptorBindingFlagsEXT*)forMarshaling->pBindingFlags, forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
+}
+
+void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pBindingFlags, forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
+ vkStream->read((VkDescriptorBindingFlagsEXT*)forUnmarshaling->pBindingFlags, forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlagsEXT));
+}
+
+void marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->runtimeDescriptorArray, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->runtimeDescriptorArray, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
+}
+
+void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+ VulkanStream* vkStream,
+ VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pDescriptorCounts, forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pDescriptorCounts, forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
+}
+
+void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+ VulkanStream* vkStream,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+ VulkanStream* vkStream,
+ VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVariableDescriptorCount, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
+}
+
+void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkQueueGlobalPriorityEXT*)&forUnmarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
+}
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void marshal_VkImportMemoryHostPointerInfoEXT(
+ VulkanStream* vkStream,
+ const VkImportMemoryHostPointerInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_350 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
+ vkStream->putBe64(cgen_var_350);
+ if (forMarshaling->pHostPointer)
+ {
+ vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
+ }
+}
+
+void unmarshal_VkImportMemoryHostPointerInfoEXT(
+ VulkanStream* vkStream,
+ VkImportMemoryHostPointerInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ // WARNING PTR CHECK
+ forUnmarshaling->pHostPointer = (void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pHostPointer)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(uint8_t));
+ vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(uint8_t));
+ }
+}
+
+void marshal_VkMemoryHostPointerPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkMemoryHostPointerPropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryHostPointerPropertiesEXT(
+ VulkanStream* vkStream,
+ VkMemoryHostPointerPropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
+}
+
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, 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));
+ vkStream->write((uint32_t*)&forMarshaling->simdPerComputeUnit, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->wavefrontsPerSimd, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->wavefrontSize, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->sgprsPerSimd, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minSgprAllocation, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxSgprAllocation, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->sgprAllocationGranularity, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->vgprsPerSimd, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minVgprAllocation, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxVgprAllocation, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->vgprAllocationGranularity, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (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));
+ vkStream->read((uint32_t*)&forUnmarshaling->simdPerComputeUnit, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->wavefrontsPerSimd, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->wavefrontSize, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->sgprsPerSimd, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minSgprAllocation, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxSgprAllocation, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->sgprAllocationGranularity, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->vgprsPerSimd, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minVgprAllocation, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVgprAllocation, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->vgprAllocationGranularity, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+}
+
+void marshal_VkVertexInputBindingDivisorDescriptionEXT(
+ VulkanStream* vkStream,
+ const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling)
+{
+ vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
+}
+
+void unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
+ VulkanStream* vkStream,
+ VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling)
+{
+ vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->divisor, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i)
+ {
+ marshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling->pVertexBindingDivisors + i));
+ }
+}
+
+void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pVertexBindingDivisors, forUnmarshaling->vertexBindingDivisorCount * sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDivisorCount; ++i)
+ {
+ unmarshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, (VkVertexInputBindingDivisorDescriptionEXT*)(forUnmarshaling->pVertexBindingDivisors + i));
+ }
+}
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void marshal_VkQueueFamilyCheckpointPropertiesNV(
+ VulkanStream* vkStream,
+ const VkQueueFamilyCheckpointPropertiesNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
+}
+
+void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
+ VulkanStream* vkStream,
+ VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
+}
+
+void marshal_VkCheckpointDataNV(
+ VulkanStream* vkStream,
+ const VkCheckpointDataNV* forMarshaling)
+{
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
+ vkStream->putBe32(pNext_size);
+ if (pNext_size)
+ {
+ vkStream->write((void*)forMarshaling->pNext, sizeof(VkStructureType));
+ marshal_extension_struct(vkStream, forMarshaling->pNext);
+ }
+ vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_352 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
+ vkStream->putBe64(cgen_var_352);
+ if (forMarshaling->pCheckpointMarker)
+ {
+ vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
+ }
+}
+
+void unmarshal_VkCheckpointDataNV(
+ VulkanStream* vkStream,
+ VkCheckpointDataNV* forUnmarshaling)
+{
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, pNext_size);
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineStageFlagBits*)&forUnmarshaling->stage, sizeof(VkPipelineStageFlagBits));
+ // WARNING PTR CHECK
+ forUnmarshaling->pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pCheckpointMarker)
+ {
+ vkStream->alloc((void**)&forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
+ vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
+ }
+}
+
+#endif
+void marshal_extension_struct(
+ VulkanStream* vkStream,
+ const void* structExtension)
+{
+ if (!structExtension)
+ {
+ return;
+ }
+ uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
+ switch(structType)
+ {
+#ifdef VK_VERSION_1_1
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+ {
+ marshal_VkPhysicalDeviceSubgroupProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+ {
+ marshal_VkPhysicalDevice16BitStorageFeatures(vkStream, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+ {
+ marshal_VkMemoryDedicatedRequirements(vkStream, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+ {
+ marshal_VkMemoryDedicatedAllocateInfo(vkStream, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+ {
+ marshal_VkMemoryAllocateFlagsInfo(vkStream, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+ {
+ marshal_VkDeviceGroupRenderPassBeginInfo(vkStream, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+ {
+ marshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+ {
+ marshal_VkDeviceGroupSubmitInfo(vkStream, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+ {
+ marshal_VkDeviceGroupBindSparseInfo(vkStream, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+ {
+ marshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+ {
+ marshal_VkBindImageMemoryDeviceGroupInfo(vkStream, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+ {
+ marshal_VkDeviceGroupDeviceCreateInfo(vkStream, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+ {
+ marshal_VkPhysicalDeviceFeatures2(vkStream, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+ {
+ marshal_VkPhysicalDevicePointClippingProperties(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+ {
+ marshal_VkImageViewUsageCreateInfo(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+ {
+ marshal_VkRenderPassMultiviewCreateInfo(vkStream, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+ {
+ marshal_VkPhysicalDeviceMultiviewFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+ {
+ marshal_VkPhysicalDeviceMultiviewProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+ {
+ marshal_VkPhysicalDeviceVariablePointerFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+ {
+ marshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+ {
+ marshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+ {
+ marshal_VkProtectedSubmitInfo(vkStream, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+ {
+ marshal_VkSamplerYcbcrConversionInfo(vkStream, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+ {
+ marshal_VkBindImagePlaneMemoryInfo(vkStream, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+ {
+ marshal_VkImagePlaneMemoryRequirementsInfo(vkStream, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+ {
+ marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+ {
+ marshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+ {
+ marshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+ {
+ marshal_VkExternalImageFormatProperties(vkStream, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+ {
+ marshal_VkPhysicalDeviceIDProperties(vkStream, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+ {
+ marshal_VkExternalMemoryImageCreateInfo(vkStream, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+ {
+ marshal_VkExternalMemoryBufferCreateInfo(vkStream, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+ {
+ marshal_VkExportMemoryAllocateInfo(vkStream, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+ {
+ marshal_VkExportFenceCreateInfo(vkStream, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+ {
+ marshal_VkExportSemaphoreCreateInfo(vkStream, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+ {
+ marshal_VkPhysicalDeviceMaintenance3Properties(vkStream, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+ {
+ marshal_VkPhysicalDeviceShaderDrawParameterFeatures(vkStream, reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>(structExtension));
+ break;
+ }
+#endif
+#ifdef VK_KHR_swapchain
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+ {
+ marshal_VkImageSwapchainCreateInfoKHR(vkStream, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+ {
+ marshal_VkBindImageMemorySwapchainInfoKHR(vkStream, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+ {
+ marshal_VkDeviceGroupPresentInfoKHR(vkStream, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+ {
+ marshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ {
+ marshal_VkExportMemoryWin32HandleInfoKHR(vkStream, 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+ {
+ marshal_VkD3D12FenceSubmitInfoKHR(vkStream, 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));
+ break;
+ }
+#endif
+#ifdef VK_KHR_incremental_present
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+ {
+ marshal_VkPresentRegionsKHR(vkStream, 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));
+ 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));
+ break;
+ }
+#endif
+#ifdef VK_KHR_image_format_list
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+ {
+ marshal_VkImageFormatListCreateInfoKHR(vkStream, reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(structExtension));
+ break;
+ }
+#endif
+#ifdef VK_KHR_8bit_storage
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+ {
+ marshal_VkPhysicalDevice8BitStorageFeaturesKHR(vkStream, reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension));
+ break;
+ }
+#endif
+#ifdef VK_ANDROID_native_buffer
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+ {
+ marshal_VkNativeBufferANDROID(vkStream, 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+ {
+ marshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+ {
+ marshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+ {
+ marshal_VkExportMemoryAllocateInfoNV(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ {
+ marshal_VkExportMemoryWin32HandleInfoNV(vkStream, 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));
+ break;
+ }
+#endif
+#ifdef VK_EXT_validation_flags
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+ {
+ marshal_VkValidationFlagsEXT(vkStream, reinterpret_cast<const VkValidationFlagsEXT*>(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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+ {
+ marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, 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));
+ break;
+ }
+#endif
+#ifdef VK_EXT_display_control
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+ {
+ marshal_VkSwapchainCounterCreateInfoEXT(vkStream, 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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+ {
+ marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+ {
+ marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+ {
+ marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+ {
+ marshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+ {
+ marshal_VkExternalFormatANDROID(vkStream, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension));
+ break;
+ }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+ {
+ marshal_VkSamplerReductionModeCreateInfoEXT(vkStream, reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+ {
+ marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(structExtension));
+ break;
+ }
+#endif
+#ifdef VK_EXT_sample_locations
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+ {
+ marshal_VkSampleLocationsInfoEXT(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+ {
+ marshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+ {
+ marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+ {
+ marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, 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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+ {
+ marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(vkStream, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+ {
+ marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+ {
+ marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+ {
+ marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(vkStream, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+ {
+ marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(vkStream, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+ {
+ marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+ {
+ marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(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));
+ break;
+ }
+#endif
+ default:
+ {
+ return;
+ }
+ }
+}
+
+void unmarshal_extension_struct(
+ VulkanStream* vkStream,
+ void* structExtension_out)
+{
+ if (!structExtension_out)
+ {
+ return;
+ }
+ uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
+ switch(structType)
+ {
+#ifdef VK_VERSION_1_1
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+ {
+ unmarshal_VkPhysicalDeviceSubgroupProperties(vkStream, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+ {
+ unmarshal_VkPhysicalDevice16BitStorageFeatures(vkStream, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+ {
+ unmarshal_VkMemoryDedicatedRequirements(vkStream, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+ {
+ unmarshal_VkMemoryDedicatedAllocateInfo(vkStream, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+ {
+ unmarshal_VkMemoryAllocateFlagsInfo(vkStream, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+ {
+ unmarshal_VkDeviceGroupRenderPassBeginInfo(vkStream, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+ {
+ unmarshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+ {
+ unmarshal_VkDeviceGroupSubmitInfo(vkStream, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+ {
+ unmarshal_VkDeviceGroupBindSparseInfo(vkStream, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+ {
+ unmarshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+ {
+ unmarshal_VkBindImageMemoryDeviceGroupInfo(vkStream, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+ {
+ unmarshal_VkDeviceGroupDeviceCreateInfo(vkStream, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+ {
+ unmarshal_VkPhysicalDeviceFeatures2(vkStream, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+ {
+ unmarshal_VkPhysicalDevicePointClippingProperties(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+ {
+ unmarshal_VkImageViewUsageCreateInfo(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+ {
+ unmarshal_VkRenderPassMultiviewCreateInfo(vkStream, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+ {
+ unmarshal_VkPhysicalDeviceMultiviewFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+ {
+ unmarshal_VkPhysicalDeviceMultiviewProperties(vkStream, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES:
+ {
+ unmarshal_VkPhysicalDeviceVariablePointerFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+ {
+ unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+ {
+ unmarshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+ {
+ unmarshal_VkProtectedSubmitInfo(vkStream, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+ {
+ unmarshal_VkSamplerYcbcrConversionInfo(vkStream, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+ {
+ unmarshal_VkBindImagePlaneMemoryInfo(vkStream, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+ {
+ unmarshal_VkImagePlaneMemoryRequirementsInfo(vkStream, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+ {
+ unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+ {
+ unmarshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+ {
+ unmarshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+ {
+ unmarshal_VkExternalImageFormatProperties(vkStream, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+ {
+ unmarshal_VkPhysicalDeviceIDProperties(vkStream, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+ {
+ unmarshal_VkExternalMemoryImageCreateInfo(vkStream, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+ {
+ unmarshal_VkExternalMemoryBufferCreateInfo(vkStream, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+ {
+ unmarshal_VkExportMemoryAllocateInfo(vkStream, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+ {
+ unmarshal_VkExportFenceCreateInfo(vkStream, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+ {
+ unmarshal_VkExportSemaphoreCreateInfo(vkStream, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+ {
+ unmarshal_VkPhysicalDeviceMaintenance3Properties(vkStream, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES:
+ {
+ unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures(vkStream, reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+ {
+ unmarshal_VkBindImageMemorySwapchainInfoKHR(vkStream, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+ {
+ unmarshal_VkDeviceGroupPresentInfoKHR(vkStream, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+ {
+ unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+ {
+ unmarshal_VkExportMemoryWin32HandleInfoKHR(vkStream, 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+ {
+ unmarshal_VkD3D12FenceSubmitInfoKHR(vkStream, 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));
+ break;
+ }
+#endif
+#ifdef VK_KHR_incremental_present
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+ {
+ unmarshal_VkPresentRegionsKHR(vkStream, 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));
+ 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));
+ break;
+ }
+#endif
+#ifdef VK_KHR_image_format_list
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+ {
+ unmarshal_VkImageFormatListCreateInfoKHR(vkStream, reinterpret_cast<VkImageFormatListCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_KHR_8bit_storage
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+ {
+ unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR(vkStream, reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_ANDROID_native_buffer
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
+ {
+ unmarshal_VkNativeBufferANDROID(vkStream, 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+ {
+ unmarshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+ {
+ unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+ {
+ unmarshal_VkExportMemoryAllocateInfoNV(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+ {
+ unmarshal_VkExportMemoryWin32HandleInfoNV(vkStream, 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));
+ break;
+ }
+#endif
+#ifdef VK_EXT_validation_flags
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+ {
+ unmarshal_VkValidationFlagsEXT(vkStream, reinterpret_cast<VkValidationFlagsEXT*>(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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+ {
+ unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, 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));
+ break;
+ }
+#endif
+#ifdef VK_EXT_display_control
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+ {
+ unmarshal_VkSwapchainCounterCreateInfoEXT(vkStream, 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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+ {
+ unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+ {
+ unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+ {
+ unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+ {
+ unmarshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+ {
+ unmarshal_VkExternalFormatANDROID(vkStream, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ break;
+ }
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+ {
+ unmarshal_VkSamplerReductionModeCreateInfoEXT(vkStream, reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+ {
+ unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+ {
+ unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+ {
+ unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+ {
+ unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, 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));
+ 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));
+ 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));
+ 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));
+ break;
+ }
+#endif
+#ifdef VK_EXT_descriptor_indexing
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+ {
+ unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(vkStream, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+ {
+ unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+ {
+ unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+ {
+ unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(vkStream, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+ {
+ unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(vkStream, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+ {
+ unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(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));
+ 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));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+ {
+ unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(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));
+ break;
+ }
+#endif
+ default:
+ {
+ return;
+ }
+ }
+}
+
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
new file mode 100644
index 0000000..a6ac11f
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -0,0 +1,3362 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module goldfish_vk_marshaling_guest
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "vk_platform_compat.h"
+
+#include "goldfish_vk_marshaling_guest.h"
+#include "goldfish_vk_private_defs.h"
+#include "VulkanStream.h"
+
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+void marshal_VkApplicationInfo(
+ VulkanStream* vkStream,
+ const VkApplicationInfo* forMarshaling);
+
+void unmarshal_VkApplicationInfo(
+ VulkanStream* vkStream,
+ VkApplicationInfo* forUnmarshaling);
+
+void marshal_VkInstanceCreateInfo(
+ VulkanStream* vkStream,
+ const VkInstanceCreateInfo* forMarshaling);
+
+void unmarshal_VkInstanceCreateInfo(
+ VulkanStream* vkStream,
+ VkInstanceCreateInfo* forUnmarshaling);
+
+void marshal_VkAllocationCallbacks(
+ VulkanStream* vkStream,
+ const VkAllocationCallbacks* forMarshaling);
+
+void unmarshal_VkAllocationCallbacks(
+ VulkanStream* vkStream,
+ VkAllocationCallbacks* forUnmarshaling);
+
+#define OP_vkCreateInstance 20000
+#define OP_vkDestroyInstance 20001
+#define OP_vkEnumeratePhysicalDevices 20002
+void marshal_VkPhysicalDeviceFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceFeatures* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceFeatures 20003
+void marshal_VkFormatProperties(
+ VulkanStream* vkStream,
+ const VkFormatProperties* forMarshaling);
+
+void unmarshal_VkFormatProperties(
+ VulkanStream* vkStream,
+ VkFormatProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceFormatProperties 20004
+void marshal_VkExtent3D(
+ VulkanStream* vkStream,
+ const VkExtent3D* forMarshaling);
+
+void unmarshal_VkExtent3D(
+ VulkanStream* vkStream,
+ VkExtent3D* forUnmarshaling);
+
+void marshal_VkImageFormatProperties(
+ VulkanStream* vkStream,
+ const VkImageFormatProperties* forMarshaling);
+
+void unmarshal_VkImageFormatProperties(
+ VulkanStream* vkStream,
+ VkImageFormatProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceImageFormatProperties 20005
+void marshal_VkPhysicalDeviceLimits(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceLimits* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceLimits(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceLimits* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSparseProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSparseProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSparseProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSparseProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceProperties 20006
+void marshal_VkQueueFamilyProperties(
+ VulkanStream* vkStream,
+ const VkQueueFamilyProperties* forMarshaling);
+
+void unmarshal_VkQueueFamilyProperties(
+ VulkanStream* vkStream,
+ VkQueueFamilyProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceQueueFamilyProperties 20007
+void marshal_VkMemoryType(
+ VulkanStream* vkStream,
+ const VkMemoryType* forMarshaling);
+
+void unmarshal_VkMemoryType(
+ VulkanStream* vkStream,
+ VkMemoryType* forUnmarshaling);
+
+void marshal_VkMemoryHeap(
+ VulkanStream* vkStream,
+ const VkMemoryHeap* forMarshaling);
+
+void unmarshal_VkMemoryHeap(
+ VulkanStream* vkStream,
+ VkMemoryHeap* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMemoryProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMemoryProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMemoryProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMemoryProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceMemoryProperties 20008
+#define OP_vkGetInstanceProcAddr 20009
+#define OP_vkGetDeviceProcAddr 20010
+void marshal_VkDeviceQueueCreateInfo(
+ VulkanStream* vkStream,
+ const VkDeviceQueueCreateInfo* forMarshaling);
+
+void unmarshal_VkDeviceQueueCreateInfo(
+ VulkanStream* vkStream,
+ VkDeviceQueueCreateInfo* forUnmarshaling);
+
+void marshal_VkDeviceCreateInfo(
+ VulkanStream* vkStream,
+ const VkDeviceCreateInfo* forMarshaling);
+
+void unmarshal_VkDeviceCreateInfo(
+ VulkanStream* vkStream,
+ VkDeviceCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateDevice 20011
+#define OP_vkDestroyDevice 20012
+void marshal_VkExtensionProperties(
+ VulkanStream* vkStream,
+ const VkExtensionProperties* forMarshaling);
+
+void unmarshal_VkExtensionProperties(
+ VulkanStream* vkStream,
+ VkExtensionProperties* forUnmarshaling);
+
+#define OP_vkEnumerateInstanceExtensionProperties 20013
+#define OP_vkEnumerateDeviceExtensionProperties 20014
+void marshal_VkLayerProperties(
+ VulkanStream* vkStream,
+ const VkLayerProperties* forMarshaling);
+
+void unmarshal_VkLayerProperties(
+ VulkanStream* vkStream,
+ VkLayerProperties* forUnmarshaling);
+
+#define OP_vkEnumerateInstanceLayerProperties 20015
+#define OP_vkEnumerateDeviceLayerProperties 20016
+#define OP_vkGetDeviceQueue 20017
+void marshal_VkSubmitInfo(
+ VulkanStream* vkStream,
+ const VkSubmitInfo* forMarshaling);
+
+void unmarshal_VkSubmitInfo(
+ VulkanStream* vkStream,
+ VkSubmitInfo* forUnmarshaling);
+
+#define OP_vkQueueSubmit 20018
+#define OP_vkQueueWaitIdle 20019
+#define OP_vkDeviceWaitIdle 20020
+void marshal_VkMemoryAllocateInfo(
+ VulkanStream* vkStream,
+ const VkMemoryAllocateInfo* forMarshaling);
+
+void unmarshal_VkMemoryAllocateInfo(
+ VulkanStream* vkStream,
+ VkMemoryAllocateInfo* forUnmarshaling);
+
+#define OP_vkAllocateMemory 20021
+#define OP_vkFreeMemory 20022
+#define OP_vkMapMemory 20023
+#define OP_vkUnmapMemory 20024
+void marshal_VkMappedMemoryRange(
+ VulkanStream* vkStream,
+ const VkMappedMemoryRange* forMarshaling);
+
+void unmarshal_VkMappedMemoryRange(
+ VulkanStream* vkStream,
+ VkMappedMemoryRange* forUnmarshaling);
+
+#define OP_vkFlushMappedMemoryRanges 20025
+#define OP_vkInvalidateMappedMemoryRanges 20026
+#define OP_vkGetDeviceMemoryCommitment 20027
+#define OP_vkBindBufferMemory 20028
+#define OP_vkBindImageMemory 20029
+void marshal_VkMemoryRequirements(
+ VulkanStream* vkStream,
+ const VkMemoryRequirements* forMarshaling);
+
+void unmarshal_VkMemoryRequirements(
+ VulkanStream* vkStream,
+ VkMemoryRequirements* forUnmarshaling);
+
+#define OP_vkGetBufferMemoryRequirements 20030
+#define OP_vkGetImageMemoryRequirements 20031
+void marshal_VkSparseImageFormatProperties(
+ VulkanStream* vkStream,
+ const VkSparseImageFormatProperties* forMarshaling);
+
+void unmarshal_VkSparseImageFormatProperties(
+ VulkanStream* vkStream,
+ VkSparseImageFormatProperties* forUnmarshaling);
+
+void marshal_VkSparseImageMemoryRequirements(
+ VulkanStream* vkStream,
+ const VkSparseImageMemoryRequirements* forMarshaling);
+
+void unmarshal_VkSparseImageMemoryRequirements(
+ VulkanStream* vkStream,
+ VkSparseImageMemoryRequirements* forUnmarshaling);
+
+#define OP_vkGetImageSparseMemoryRequirements 20032
+#define OP_vkGetPhysicalDeviceSparseImageFormatProperties 20033
+void marshal_VkSparseMemoryBind(
+ VulkanStream* vkStream,
+ const VkSparseMemoryBind* forMarshaling);
+
+void unmarshal_VkSparseMemoryBind(
+ VulkanStream* vkStream,
+ VkSparseMemoryBind* forUnmarshaling);
+
+void marshal_VkSparseBufferMemoryBindInfo(
+ VulkanStream* vkStream,
+ const VkSparseBufferMemoryBindInfo* forMarshaling);
+
+void unmarshal_VkSparseBufferMemoryBindInfo(
+ VulkanStream* vkStream,
+ VkSparseBufferMemoryBindInfo* forUnmarshaling);
+
+void marshal_VkSparseImageOpaqueMemoryBindInfo(
+ VulkanStream* vkStream,
+ const VkSparseImageOpaqueMemoryBindInfo* forMarshaling);
+
+void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
+ VulkanStream* vkStream,
+ VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling);
+
+void marshal_VkImageSubresource(
+ VulkanStream* vkStream,
+ const VkImageSubresource* forMarshaling);
+
+void unmarshal_VkImageSubresource(
+ VulkanStream* vkStream,
+ VkImageSubresource* forUnmarshaling);
+
+void marshal_VkOffset3D(
+ VulkanStream* vkStream,
+ const VkOffset3D* forMarshaling);
+
+void unmarshal_VkOffset3D(
+ VulkanStream* vkStream,
+ VkOffset3D* forUnmarshaling);
+
+void marshal_VkSparseImageMemoryBind(
+ VulkanStream* vkStream,
+ const VkSparseImageMemoryBind* forMarshaling);
+
+void unmarshal_VkSparseImageMemoryBind(
+ VulkanStream* vkStream,
+ VkSparseImageMemoryBind* forUnmarshaling);
+
+void marshal_VkSparseImageMemoryBindInfo(
+ VulkanStream* vkStream,
+ const VkSparseImageMemoryBindInfo* forMarshaling);
+
+void unmarshal_VkSparseImageMemoryBindInfo(
+ VulkanStream* vkStream,
+ VkSparseImageMemoryBindInfo* forUnmarshaling);
+
+void marshal_VkBindSparseInfo(
+ VulkanStream* vkStream,
+ const VkBindSparseInfo* forMarshaling);
+
+void unmarshal_VkBindSparseInfo(
+ VulkanStream* vkStream,
+ VkBindSparseInfo* forUnmarshaling);
+
+#define OP_vkQueueBindSparse 20034
+void marshal_VkFenceCreateInfo(
+ VulkanStream* vkStream,
+ const VkFenceCreateInfo* forMarshaling);
+
+void unmarshal_VkFenceCreateInfo(
+ VulkanStream* vkStream,
+ VkFenceCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateFence 20035
+#define OP_vkDestroyFence 20036
+#define OP_vkResetFences 20037
+#define OP_vkGetFenceStatus 20038
+#define OP_vkWaitForFences 20039
+void marshal_VkSemaphoreCreateInfo(
+ VulkanStream* vkStream,
+ const VkSemaphoreCreateInfo* forMarshaling);
+
+void unmarshal_VkSemaphoreCreateInfo(
+ VulkanStream* vkStream,
+ VkSemaphoreCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateSemaphore 20040
+#define OP_vkDestroySemaphore 20041
+void marshal_VkEventCreateInfo(
+ VulkanStream* vkStream,
+ const VkEventCreateInfo* forMarshaling);
+
+void unmarshal_VkEventCreateInfo(
+ VulkanStream* vkStream,
+ VkEventCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateEvent 20042
+#define OP_vkDestroyEvent 20043
+#define OP_vkGetEventStatus 20044
+#define OP_vkSetEvent 20045
+#define OP_vkResetEvent 20046
+void marshal_VkQueryPoolCreateInfo(
+ VulkanStream* vkStream,
+ const VkQueryPoolCreateInfo* forMarshaling);
+
+void unmarshal_VkQueryPoolCreateInfo(
+ VulkanStream* vkStream,
+ VkQueryPoolCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateQueryPool 20047
+#define OP_vkDestroyQueryPool 20048
+#define OP_vkGetQueryPoolResults 20049
+void marshal_VkBufferCreateInfo(
+ VulkanStream* vkStream,
+ const VkBufferCreateInfo* forMarshaling);
+
+void unmarshal_VkBufferCreateInfo(
+ VulkanStream* vkStream,
+ VkBufferCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateBuffer 20050
+#define OP_vkDestroyBuffer 20051
+void marshal_VkBufferViewCreateInfo(
+ VulkanStream* vkStream,
+ const VkBufferViewCreateInfo* forMarshaling);
+
+void unmarshal_VkBufferViewCreateInfo(
+ VulkanStream* vkStream,
+ VkBufferViewCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateBufferView 20052
+#define OP_vkDestroyBufferView 20053
+void marshal_VkImageCreateInfo(
+ VulkanStream* vkStream,
+ const VkImageCreateInfo* forMarshaling);
+
+void unmarshal_VkImageCreateInfo(
+ VulkanStream* vkStream,
+ VkImageCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateImage 20054
+#define OP_vkDestroyImage 20055
+void marshal_VkSubresourceLayout(
+ VulkanStream* vkStream,
+ const VkSubresourceLayout* forMarshaling);
+
+void unmarshal_VkSubresourceLayout(
+ VulkanStream* vkStream,
+ VkSubresourceLayout* forUnmarshaling);
+
+#define OP_vkGetImageSubresourceLayout 20056
+void marshal_VkComponentMapping(
+ VulkanStream* vkStream,
+ const VkComponentMapping* forMarshaling);
+
+void unmarshal_VkComponentMapping(
+ VulkanStream* vkStream,
+ VkComponentMapping* forUnmarshaling);
+
+void marshal_VkImageSubresourceRange(
+ VulkanStream* vkStream,
+ const VkImageSubresourceRange* forMarshaling);
+
+void unmarshal_VkImageSubresourceRange(
+ VulkanStream* vkStream,
+ VkImageSubresourceRange* forUnmarshaling);
+
+void marshal_VkImageViewCreateInfo(
+ VulkanStream* vkStream,
+ const VkImageViewCreateInfo* forMarshaling);
+
+void unmarshal_VkImageViewCreateInfo(
+ VulkanStream* vkStream,
+ VkImageViewCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateImageView 20057
+#define OP_vkDestroyImageView 20058
+void marshal_VkShaderModuleCreateInfo(
+ VulkanStream* vkStream,
+ const VkShaderModuleCreateInfo* forMarshaling);
+
+void unmarshal_VkShaderModuleCreateInfo(
+ VulkanStream* vkStream,
+ VkShaderModuleCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateShaderModule 20059
+#define OP_vkDestroyShaderModule 20060
+void marshal_VkPipelineCacheCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineCacheCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineCacheCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineCacheCreateInfo* forUnmarshaling);
+
+#define OP_vkCreatePipelineCache 20061
+#define OP_vkDestroyPipelineCache 20062
+#define OP_vkGetPipelineCacheData 20063
+#define OP_vkMergePipelineCaches 20064
+void marshal_VkSpecializationMapEntry(
+ VulkanStream* vkStream,
+ const VkSpecializationMapEntry* forMarshaling);
+
+void unmarshal_VkSpecializationMapEntry(
+ VulkanStream* vkStream,
+ VkSpecializationMapEntry* forUnmarshaling);
+
+void marshal_VkSpecializationInfo(
+ VulkanStream* vkStream,
+ const VkSpecializationInfo* forMarshaling);
+
+void unmarshal_VkSpecializationInfo(
+ VulkanStream* vkStream,
+ VkSpecializationInfo* forUnmarshaling);
+
+void marshal_VkPipelineShaderStageCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineShaderStageCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineShaderStageCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineShaderStageCreateInfo* forUnmarshaling);
+
+void marshal_VkVertexInputBindingDescription(
+ VulkanStream* vkStream,
+ const VkVertexInputBindingDescription* forMarshaling);
+
+void unmarshal_VkVertexInputBindingDescription(
+ VulkanStream* vkStream,
+ VkVertexInputBindingDescription* forUnmarshaling);
+
+void marshal_VkVertexInputAttributeDescription(
+ VulkanStream* vkStream,
+ const VkVertexInputAttributeDescription* forMarshaling);
+
+void unmarshal_VkVertexInputAttributeDescription(
+ VulkanStream* vkStream,
+ VkVertexInputAttributeDescription* forUnmarshaling);
+
+void marshal_VkPipelineVertexInputStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineVertexInputStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineVertexInputStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineVertexInputStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineInputAssemblyStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineInputAssemblyStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineTessellationStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineTessellationStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineTessellationStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineTessellationStateCreateInfo* forUnmarshaling);
+
+void marshal_VkViewport(
+ VulkanStream* vkStream,
+ const VkViewport* forMarshaling);
+
+void unmarshal_VkViewport(
+ VulkanStream* vkStream,
+ VkViewport* forUnmarshaling);
+
+void marshal_VkOffset2D(
+ VulkanStream* vkStream,
+ const VkOffset2D* forMarshaling);
+
+void unmarshal_VkOffset2D(
+ VulkanStream* vkStream,
+ VkOffset2D* forUnmarshaling);
+
+void marshal_VkExtent2D(
+ VulkanStream* vkStream,
+ const VkExtent2D* forMarshaling);
+
+void unmarshal_VkExtent2D(
+ VulkanStream* vkStream,
+ VkExtent2D* forUnmarshaling);
+
+void marshal_VkRect2D(
+ VulkanStream* vkStream,
+ const VkRect2D* forMarshaling);
+
+void unmarshal_VkRect2D(
+ VulkanStream* vkStream,
+ VkRect2D* forUnmarshaling);
+
+void marshal_VkPipelineViewportStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineViewportStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineViewportStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineViewportStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineRasterizationStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineRasterizationStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineRasterizationStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineMultisampleStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineMultisampleStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineMultisampleStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineMultisampleStateCreateInfo* forUnmarshaling);
+
+void marshal_VkStencilOpState(
+ VulkanStream* vkStream,
+ const VkStencilOpState* forMarshaling);
+
+void unmarshal_VkStencilOpState(
+ VulkanStream* vkStream,
+ VkStencilOpState* forUnmarshaling);
+
+void marshal_VkPipelineDepthStencilStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineDepthStencilStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineDepthStencilStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineDepthStencilStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineColorBlendAttachmentState(
+ VulkanStream* vkStream,
+ const VkPipelineColorBlendAttachmentState* forMarshaling);
+
+void unmarshal_VkPipelineColorBlendAttachmentState(
+ VulkanStream* vkStream,
+ VkPipelineColorBlendAttachmentState* forUnmarshaling);
+
+void marshal_VkPipelineColorBlendStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineColorBlendStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineColorBlendStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineColorBlendStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineDynamicStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineDynamicStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineDynamicStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineDynamicStateCreateInfo* forUnmarshaling);
+
+void marshal_VkGraphicsPipelineCreateInfo(
+ VulkanStream* vkStream,
+ const VkGraphicsPipelineCreateInfo* forMarshaling);
+
+void unmarshal_VkGraphicsPipelineCreateInfo(
+ VulkanStream* vkStream,
+ VkGraphicsPipelineCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateGraphicsPipelines 20065
+void marshal_VkComputePipelineCreateInfo(
+ VulkanStream* vkStream,
+ const VkComputePipelineCreateInfo* forMarshaling);
+
+void unmarshal_VkComputePipelineCreateInfo(
+ VulkanStream* vkStream,
+ VkComputePipelineCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateComputePipelines 20066
+#define OP_vkDestroyPipeline 20067
+void marshal_VkPushConstantRange(
+ VulkanStream* vkStream,
+ const VkPushConstantRange* forMarshaling);
+
+void unmarshal_VkPushConstantRange(
+ VulkanStream* vkStream,
+ VkPushConstantRange* forUnmarshaling);
+
+void marshal_VkPipelineLayoutCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineLayoutCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineLayoutCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineLayoutCreateInfo* forUnmarshaling);
+
+#define OP_vkCreatePipelineLayout 20068
+#define OP_vkDestroyPipelineLayout 20069
+void marshal_VkSamplerCreateInfo(
+ VulkanStream* vkStream,
+ const VkSamplerCreateInfo* forMarshaling);
+
+void unmarshal_VkSamplerCreateInfo(
+ VulkanStream* vkStream,
+ VkSamplerCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateSampler 20070
+#define OP_vkDestroySampler 20071
+void marshal_VkDescriptorSetLayoutBinding(
+ VulkanStream* vkStream,
+ const VkDescriptorSetLayoutBinding* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutBinding(
+ VulkanStream* vkStream,
+ VkDescriptorSetLayoutBinding* forUnmarshaling);
+
+void marshal_VkDescriptorSetLayoutCreateInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorSetLayoutCreateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutCreateInfo(
+ VulkanStream* vkStream,
+ VkDescriptorSetLayoutCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateDescriptorSetLayout 20072
+#define OP_vkDestroyDescriptorSetLayout 20073
+void marshal_VkDescriptorPoolSize(
+ VulkanStream* vkStream,
+ const VkDescriptorPoolSize* forMarshaling);
+
+void unmarshal_VkDescriptorPoolSize(
+ VulkanStream* vkStream,
+ VkDescriptorPoolSize* forUnmarshaling);
+
+void marshal_VkDescriptorPoolCreateInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorPoolCreateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorPoolCreateInfo(
+ VulkanStream* vkStream,
+ VkDescriptorPoolCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateDescriptorPool 20074
+#define OP_vkDestroyDescriptorPool 20075
+#define OP_vkResetDescriptorPool 20076
+void marshal_VkDescriptorSetAllocateInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorSetAllocateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorSetAllocateInfo(
+ VulkanStream* vkStream,
+ VkDescriptorSetAllocateInfo* forUnmarshaling);
+
+#define OP_vkAllocateDescriptorSets 20077
+#define OP_vkFreeDescriptorSets 20078
+void marshal_VkDescriptorImageInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorImageInfo* forMarshaling);
+
+void unmarshal_VkDescriptorImageInfo(
+ VulkanStream* vkStream,
+ VkDescriptorImageInfo* forUnmarshaling);
+
+void marshal_VkDescriptorBufferInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorBufferInfo* forMarshaling);
+
+void unmarshal_VkDescriptorBufferInfo(
+ VulkanStream* vkStream,
+ VkDescriptorBufferInfo* forUnmarshaling);
+
+void marshal_VkWriteDescriptorSet(
+ VulkanStream* vkStream,
+ const VkWriteDescriptorSet* forMarshaling);
+
+void unmarshal_VkWriteDescriptorSet(
+ VulkanStream* vkStream,
+ VkWriteDescriptorSet* forUnmarshaling);
+
+void marshal_VkCopyDescriptorSet(
+ VulkanStream* vkStream,
+ const VkCopyDescriptorSet* forMarshaling);
+
+void unmarshal_VkCopyDescriptorSet(
+ VulkanStream* vkStream,
+ VkCopyDescriptorSet* forUnmarshaling);
+
+#define OP_vkUpdateDescriptorSets 20079
+void marshal_VkFramebufferCreateInfo(
+ VulkanStream* vkStream,
+ const VkFramebufferCreateInfo* forMarshaling);
+
+void unmarshal_VkFramebufferCreateInfo(
+ VulkanStream* vkStream,
+ VkFramebufferCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateFramebuffer 20080
+#define OP_vkDestroyFramebuffer 20081
+void marshal_VkAttachmentDescription(
+ VulkanStream* vkStream,
+ const VkAttachmentDescription* forMarshaling);
+
+void unmarshal_VkAttachmentDescription(
+ VulkanStream* vkStream,
+ VkAttachmentDescription* forUnmarshaling);
+
+void marshal_VkAttachmentReference(
+ VulkanStream* vkStream,
+ const VkAttachmentReference* forMarshaling);
+
+void unmarshal_VkAttachmentReference(
+ VulkanStream* vkStream,
+ VkAttachmentReference* forUnmarshaling);
+
+void marshal_VkSubpassDescription(
+ VulkanStream* vkStream,
+ const VkSubpassDescription* forMarshaling);
+
+void unmarshal_VkSubpassDescription(
+ VulkanStream* vkStream,
+ VkSubpassDescription* forUnmarshaling);
+
+void marshal_VkSubpassDependency(
+ VulkanStream* vkStream,
+ const VkSubpassDependency* forMarshaling);
+
+void unmarshal_VkSubpassDependency(
+ VulkanStream* vkStream,
+ VkSubpassDependency* forUnmarshaling);
+
+void marshal_VkRenderPassCreateInfo(
+ VulkanStream* vkStream,
+ const VkRenderPassCreateInfo* forMarshaling);
+
+void unmarshal_VkRenderPassCreateInfo(
+ VulkanStream* vkStream,
+ VkRenderPassCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateRenderPass 20082
+#define OP_vkDestroyRenderPass 20083
+#define OP_vkGetRenderAreaGranularity 20084
+void marshal_VkCommandPoolCreateInfo(
+ VulkanStream* vkStream,
+ const VkCommandPoolCreateInfo* forMarshaling);
+
+void unmarshal_VkCommandPoolCreateInfo(
+ VulkanStream* vkStream,
+ VkCommandPoolCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateCommandPool 20085
+#define OP_vkDestroyCommandPool 20086
+#define OP_vkResetCommandPool 20087
+void marshal_VkCommandBufferAllocateInfo(
+ VulkanStream* vkStream,
+ const VkCommandBufferAllocateInfo* forMarshaling);
+
+void unmarshal_VkCommandBufferAllocateInfo(
+ VulkanStream* vkStream,
+ VkCommandBufferAllocateInfo* forUnmarshaling);
+
+#define OP_vkAllocateCommandBuffers 20088
+#define OP_vkFreeCommandBuffers 20089
+void marshal_VkCommandBufferInheritanceInfo(
+ VulkanStream* vkStream,
+ const VkCommandBufferInheritanceInfo* forMarshaling);
+
+void unmarshal_VkCommandBufferInheritanceInfo(
+ VulkanStream* vkStream,
+ VkCommandBufferInheritanceInfo* forUnmarshaling);
+
+void marshal_VkCommandBufferBeginInfo(
+ VulkanStream* vkStream,
+ const VkCommandBufferBeginInfo* forMarshaling);
+
+void unmarshal_VkCommandBufferBeginInfo(
+ VulkanStream* vkStream,
+ VkCommandBufferBeginInfo* forUnmarshaling);
+
+#define OP_vkBeginCommandBuffer 20090
+#define OP_vkEndCommandBuffer 20091
+#define OP_vkResetCommandBuffer 20092
+#define OP_vkCmdBindPipeline 20093
+#define OP_vkCmdSetViewport 20094
+#define OP_vkCmdSetScissor 20095
+#define OP_vkCmdSetLineWidth 20096
+#define OP_vkCmdSetDepthBias 20097
+#define OP_vkCmdSetBlendConstants 20098
+#define OP_vkCmdSetDepthBounds 20099
+#define OP_vkCmdSetStencilCompareMask 20100
+#define OP_vkCmdSetStencilWriteMask 20101
+#define OP_vkCmdSetStencilReference 20102
+#define OP_vkCmdBindDescriptorSets 20103
+#define OP_vkCmdBindIndexBuffer 20104
+#define OP_vkCmdBindVertexBuffers 20105
+#define OP_vkCmdDraw 20106
+#define OP_vkCmdDrawIndexed 20107
+#define OP_vkCmdDrawIndirect 20108
+#define OP_vkCmdDrawIndexedIndirect 20109
+#define OP_vkCmdDispatch 20110
+#define OP_vkCmdDispatchIndirect 20111
+void marshal_VkBufferCopy(
+ VulkanStream* vkStream,
+ const VkBufferCopy* forMarshaling);
+
+void unmarshal_VkBufferCopy(
+ VulkanStream* vkStream,
+ VkBufferCopy* forUnmarshaling);
+
+#define OP_vkCmdCopyBuffer 20112
+void marshal_VkImageSubresourceLayers(
+ VulkanStream* vkStream,
+ const VkImageSubresourceLayers* forMarshaling);
+
+void unmarshal_VkImageSubresourceLayers(
+ VulkanStream* vkStream,
+ VkImageSubresourceLayers* forUnmarshaling);
+
+void marshal_VkImageCopy(
+ VulkanStream* vkStream,
+ const VkImageCopy* forMarshaling);
+
+void unmarshal_VkImageCopy(
+ VulkanStream* vkStream,
+ VkImageCopy* forUnmarshaling);
+
+#define OP_vkCmdCopyImage 20113
+void marshal_VkImageBlit(
+ VulkanStream* vkStream,
+ const VkImageBlit* forMarshaling);
+
+void unmarshal_VkImageBlit(
+ VulkanStream* vkStream,
+ VkImageBlit* forUnmarshaling);
+
+#define OP_vkCmdBlitImage 20114
+void marshal_VkBufferImageCopy(
+ VulkanStream* vkStream,
+ const VkBufferImageCopy* forMarshaling);
+
+void unmarshal_VkBufferImageCopy(
+ VulkanStream* vkStream,
+ VkBufferImageCopy* forUnmarshaling);
+
+#define OP_vkCmdCopyBufferToImage 20115
+#define OP_vkCmdCopyImageToBuffer 20116
+#define OP_vkCmdUpdateBuffer 20117
+#define OP_vkCmdFillBuffer 20118
+void marshal_VkClearColorValue(
+ VulkanStream* vkStream,
+ const VkClearColorValue* forMarshaling);
+
+void unmarshal_VkClearColorValue(
+ VulkanStream* vkStream,
+ VkClearColorValue* forUnmarshaling);
+
+#define OP_vkCmdClearColorImage 20119
+void marshal_VkClearDepthStencilValue(
+ VulkanStream* vkStream,
+ const VkClearDepthStencilValue* forMarshaling);
+
+void unmarshal_VkClearDepthStencilValue(
+ VulkanStream* vkStream,
+ VkClearDepthStencilValue* forUnmarshaling);
+
+#define OP_vkCmdClearDepthStencilImage 20120
+void marshal_VkClearValue(
+ VulkanStream* vkStream,
+ const VkClearValue* forMarshaling);
+
+void unmarshal_VkClearValue(
+ VulkanStream* vkStream,
+ VkClearValue* forUnmarshaling);
+
+void marshal_VkClearAttachment(
+ VulkanStream* vkStream,
+ const VkClearAttachment* forMarshaling);
+
+void unmarshal_VkClearAttachment(
+ VulkanStream* vkStream,
+ VkClearAttachment* forUnmarshaling);
+
+void marshal_VkClearRect(
+ VulkanStream* vkStream,
+ const VkClearRect* forMarshaling);
+
+void unmarshal_VkClearRect(
+ VulkanStream* vkStream,
+ VkClearRect* forUnmarshaling);
+
+#define OP_vkCmdClearAttachments 20121
+void marshal_VkImageResolve(
+ VulkanStream* vkStream,
+ const VkImageResolve* forMarshaling);
+
+void unmarshal_VkImageResolve(
+ VulkanStream* vkStream,
+ VkImageResolve* forUnmarshaling);
+
+#define OP_vkCmdResolveImage 20122
+#define OP_vkCmdSetEvent 20123
+#define OP_vkCmdResetEvent 20124
+void marshal_VkMemoryBarrier(
+ VulkanStream* vkStream,
+ const VkMemoryBarrier* forMarshaling);
+
+void unmarshal_VkMemoryBarrier(
+ VulkanStream* vkStream,
+ VkMemoryBarrier* forUnmarshaling);
+
+void marshal_VkBufferMemoryBarrier(
+ VulkanStream* vkStream,
+ const VkBufferMemoryBarrier* forMarshaling);
+
+void unmarshal_VkBufferMemoryBarrier(
+ VulkanStream* vkStream,
+ VkBufferMemoryBarrier* forUnmarshaling);
+
+void marshal_VkImageMemoryBarrier(
+ VulkanStream* vkStream,
+ const VkImageMemoryBarrier* forMarshaling);
+
+void unmarshal_VkImageMemoryBarrier(
+ VulkanStream* vkStream,
+ VkImageMemoryBarrier* forUnmarshaling);
+
+#define OP_vkCmdWaitEvents 20125
+#define OP_vkCmdPipelineBarrier 20126
+#define OP_vkCmdBeginQuery 20127
+#define OP_vkCmdEndQuery 20128
+#define OP_vkCmdResetQueryPool 20129
+#define OP_vkCmdWriteTimestamp 20130
+#define OP_vkCmdCopyQueryPoolResults 20131
+#define OP_vkCmdPushConstants 20132
+void marshal_VkRenderPassBeginInfo(
+ VulkanStream* vkStream,
+ const VkRenderPassBeginInfo* forMarshaling);
+
+void unmarshal_VkRenderPassBeginInfo(
+ VulkanStream* vkStream,
+ VkRenderPassBeginInfo* forUnmarshaling);
+
+#define OP_vkCmdBeginRenderPass 20133
+#define OP_vkCmdNextSubpass 20134
+#define OP_vkCmdEndRenderPass 20135
+#define OP_vkCmdExecuteCommands 20136
+void marshal_VkDispatchIndirectCommand(
+ VulkanStream* vkStream,
+ const VkDispatchIndirectCommand* forMarshaling);
+
+void unmarshal_VkDispatchIndirectCommand(
+ VulkanStream* vkStream,
+ VkDispatchIndirectCommand* forUnmarshaling);
+
+void marshal_VkDrawIndexedIndirectCommand(
+ VulkanStream* vkStream,
+ const VkDrawIndexedIndirectCommand* forMarshaling);
+
+void unmarshal_VkDrawIndexedIndirectCommand(
+ VulkanStream* vkStream,
+ VkDrawIndexedIndirectCommand* forUnmarshaling);
+
+void marshal_VkDrawIndirectCommand(
+ VulkanStream* vkStream,
+ const VkDrawIndirectCommand* forMarshaling);
+
+void unmarshal_VkDrawIndirectCommand(
+ VulkanStream* vkStream,
+ VkDrawIndirectCommand* forUnmarshaling);
+
+void marshal_VkBaseOutStructure(
+ VulkanStream* vkStream,
+ const VkBaseOutStructure* forMarshaling);
+
+void unmarshal_VkBaseOutStructure(
+ VulkanStream* vkStream,
+ VkBaseOutStructure* forUnmarshaling);
+
+void marshal_VkBaseInStructure(
+ VulkanStream* vkStream,
+ const VkBaseInStructure* forMarshaling);
+
+void unmarshal_VkBaseInStructure(
+ VulkanStream* vkStream,
+ VkBaseInStructure* forUnmarshaling);
+
+#endif
+#ifdef VK_VERSION_1_1
+#define OP_vkEnumerateInstanceVersion 20137
+void marshal_VkPhysicalDeviceSubgroupProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSubgroupProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSubgroupProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSubgroupProperties* forUnmarshaling);
+
+void marshal_VkBindBufferMemoryInfo(
+ VulkanStream* vkStream,
+ const VkBindBufferMemoryInfo* forMarshaling);
+
+void unmarshal_VkBindBufferMemoryInfo(
+ VulkanStream* vkStream,
+ VkBindBufferMemoryInfo* forUnmarshaling);
+
+void marshal_VkBindImageMemoryInfo(
+ VulkanStream* vkStream,
+ const VkBindImageMemoryInfo* forMarshaling);
+
+void unmarshal_VkBindImageMemoryInfo(
+ VulkanStream* vkStream,
+ VkBindImageMemoryInfo* forUnmarshaling);
+
+#define OP_vkBindBufferMemory2 20138
+#define OP_vkBindImageMemory2 20139
+void marshal_VkPhysicalDevice16BitStorageFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDevice16BitStorageFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDevice16BitStorageFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDevice16BitStorageFeatures* forUnmarshaling);
+
+void marshal_VkMemoryDedicatedRequirements(
+ VulkanStream* vkStream,
+ const VkMemoryDedicatedRequirements* forMarshaling);
+
+void unmarshal_VkMemoryDedicatedRequirements(
+ VulkanStream* vkStream,
+ VkMemoryDedicatedRequirements* forUnmarshaling);
+
+void marshal_VkMemoryDedicatedAllocateInfo(
+ VulkanStream* vkStream,
+ const VkMemoryDedicatedAllocateInfo* forMarshaling);
+
+void unmarshal_VkMemoryDedicatedAllocateInfo(
+ VulkanStream* vkStream,
+ VkMemoryDedicatedAllocateInfo* forUnmarshaling);
+
+void marshal_VkMemoryAllocateFlagsInfo(
+ VulkanStream* vkStream,
+ const VkMemoryAllocateFlagsInfo* forMarshaling);
+
+void unmarshal_VkMemoryAllocateFlagsInfo(
+ VulkanStream* vkStream,
+ VkMemoryAllocateFlagsInfo* forUnmarshaling);
+
+void marshal_VkDeviceGroupRenderPassBeginInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupRenderPassBeginInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupRenderPassBeginInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupRenderPassBeginInfo* forUnmarshaling);
+
+void marshal_VkDeviceGroupCommandBufferBeginInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupCommandBufferBeginInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling);
+
+void marshal_VkDeviceGroupSubmitInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupSubmitInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupSubmitInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupSubmitInfo* forUnmarshaling);
+
+void marshal_VkDeviceGroupBindSparseInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupBindSparseInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupBindSparseInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupBindSparseInfo* forUnmarshaling);
+
+#define OP_vkGetDeviceGroupPeerMemoryFeatures 20140
+#define OP_vkCmdSetDeviceMask 20141
+#define OP_vkCmdDispatchBase 20142
+void marshal_VkBindBufferMemoryDeviceGroupInfo(
+ VulkanStream* vkStream,
+ const VkBindBufferMemoryDeviceGroupInfo* forMarshaling);
+
+void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
+ VulkanStream* vkStream,
+ VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling);
+
+void marshal_VkBindImageMemoryDeviceGroupInfo(
+ VulkanStream* vkStream,
+ const VkBindImageMemoryDeviceGroupInfo* forMarshaling);
+
+void unmarshal_VkBindImageMemoryDeviceGroupInfo(
+ VulkanStream* vkStream,
+ VkBindImageMemoryDeviceGroupInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceGroupProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceGroupProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceGroupProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceGroupProperties* forUnmarshaling);
+
+void marshal_VkDeviceGroupDeviceCreateInfo(
+ VulkanStream* vkStream,
+ const VkDeviceGroupDeviceCreateInfo* forMarshaling);
+
+void unmarshal_VkDeviceGroupDeviceCreateInfo(
+ VulkanStream* vkStream,
+ VkDeviceGroupDeviceCreateInfo* forUnmarshaling);
+
+#define OP_vkEnumeratePhysicalDeviceGroups 20143
+void marshal_VkBufferMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ const VkBufferMemoryRequirementsInfo2* forMarshaling);
+
+void unmarshal_VkBufferMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ VkBufferMemoryRequirementsInfo2* forUnmarshaling);
+
+void marshal_VkImageMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ const VkImageMemoryRequirementsInfo2* forMarshaling);
+
+void unmarshal_VkImageMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ VkImageMemoryRequirementsInfo2* forUnmarshaling);
+
+void marshal_VkImageSparseMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ const VkImageSparseMemoryRequirementsInfo2* forMarshaling);
+
+void unmarshal_VkImageSparseMemoryRequirementsInfo2(
+ VulkanStream* vkStream,
+ VkImageSparseMemoryRequirementsInfo2* forUnmarshaling);
+
+void marshal_VkMemoryRequirements2(
+ VulkanStream* vkStream,
+ const VkMemoryRequirements2* forMarshaling);
+
+void unmarshal_VkMemoryRequirements2(
+ VulkanStream* vkStream,
+ VkMemoryRequirements2* forUnmarshaling);
+
+void marshal_VkSparseImageMemoryRequirements2(
+ VulkanStream* vkStream,
+ const VkSparseImageMemoryRequirements2* forMarshaling);
+
+void unmarshal_VkSparseImageMemoryRequirements2(
+ VulkanStream* vkStream,
+ VkSparseImageMemoryRequirements2* forUnmarshaling);
+
+#define OP_vkGetImageMemoryRequirements2 20144
+#define OP_vkGetBufferMemoryRequirements2 20145
+#define OP_vkGetImageSparseMemoryRequirements2 20146
+void marshal_VkPhysicalDeviceFeatures2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceFeatures2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFeatures2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceFeatures2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceProperties2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceProperties2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceProperties2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceProperties2* forUnmarshaling);
+
+void marshal_VkFormatProperties2(
+ VulkanStream* vkStream,
+ const VkFormatProperties2* forMarshaling);
+
+void unmarshal_VkFormatProperties2(
+ VulkanStream* vkStream,
+ VkFormatProperties2* forUnmarshaling);
+
+void marshal_VkImageFormatProperties2(
+ VulkanStream* vkStream,
+ const VkImageFormatProperties2* forMarshaling);
+
+void unmarshal_VkImageFormatProperties2(
+ VulkanStream* vkStream,
+ VkImageFormatProperties2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceImageFormatInfo2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceImageFormatInfo2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImageFormatInfo2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceImageFormatInfo2* forUnmarshaling);
+
+void marshal_VkQueueFamilyProperties2(
+ VulkanStream* vkStream,
+ const VkQueueFamilyProperties2* forMarshaling);
+
+void unmarshal_VkQueueFamilyProperties2(
+ VulkanStream* vkStream,
+ VkQueueFamilyProperties2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMemoryProperties2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMemoryProperties2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMemoryProperties2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMemoryProperties2* forUnmarshaling);
+
+void marshal_VkSparseImageFormatProperties2(
+ VulkanStream* vkStream,
+ const VkSparseImageFormatProperties2* forMarshaling);
+
+void unmarshal_VkSparseImageFormatProperties2(
+ VulkanStream* vkStream,
+ VkSparseImageFormatProperties2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceFeatures2 20147
+#define OP_vkGetPhysicalDeviceProperties2 20148
+#define OP_vkGetPhysicalDeviceFormatProperties2 20149
+#define OP_vkGetPhysicalDeviceImageFormatProperties2 20150
+#define OP_vkGetPhysicalDeviceQueueFamilyProperties2 20151
+#define OP_vkGetPhysicalDeviceMemoryProperties2 20152
+#define OP_vkGetPhysicalDeviceSparseImageFormatProperties2 20153
+#define OP_vkTrimCommandPool 20154
+void marshal_VkPhysicalDevicePointClippingProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDevicePointClippingProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePointClippingProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDevicePointClippingProperties* forUnmarshaling);
+
+void marshal_VkInputAttachmentAspectReference(
+ VulkanStream* vkStream,
+ const VkInputAttachmentAspectReference* forMarshaling);
+
+void unmarshal_VkInputAttachmentAspectReference(
+ VulkanStream* vkStream,
+ VkInputAttachmentAspectReference* forUnmarshaling);
+
+void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
+ VulkanStream* vkStream,
+ const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling);
+
+void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
+ VulkanStream* vkStream,
+ VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling);
+
+void marshal_VkImageViewUsageCreateInfo(
+ VulkanStream* vkStream,
+ const VkImageViewUsageCreateInfo* forMarshaling);
+
+void unmarshal_VkImageViewUsageCreateInfo(
+ VulkanStream* vkStream,
+ VkImageViewUsageCreateInfo* forUnmarshaling);
+
+void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+ VulkanStream* vkStream,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+ VulkanStream* vkStream,
+ VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling);
+
+void marshal_VkRenderPassMultiviewCreateInfo(
+ VulkanStream* vkStream,
+ const VkRenderPassMultiviewCreateInfo* forMarshaling);
+
+void unmarshal_VkRenderPassMultiviewCreateInfo(
+ VulkanStream* vkStream,
+ VkRenderPassMultiviewCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMultiviewFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMultiviewFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultiviewFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMultiviewFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMultiviewProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMultiviewProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultiviewProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMultiviewProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceVariablePointerFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceVariablePointerFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVariablePointerFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceVariablePointerFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceProtectedMemoryProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling);
+
+void marshal_VkDeviceQueueInfo2(
+ VulkanStream* vkStream,
+ const VkDeviceQueueInfo2* forMarshaling);
+
+void unmarshal_VkDeviceQueueInfo2(
+ VulkanStream* vkStream,
+ VkDeviceQueueInfo2* forUnmarshaling);
+
+void marshal_VkProtectedSubmitInfo(
+ VulkanStream* vkStream,
+ const VkProtectedSubmitInfo* forMarshaling);
+
+void unmarshal_VkProtectedSubmitInfo(
+ VulkanStream* vkStream,
+ VkProtectedSubmitInfo* forUnmarshaling);
+
+#define OP_vkGetDeviceQueue2 20155
+void marshal_VkSamplerYcbcrConversionCreateInfo(
+ VulkanStream* vkStream,
+ const VkSamplerYcbcrConversionCreateInfo* forMarshaling);
+
+void unmarshal_VkSamplerYcbcrConversionCreateInfo(
+ VulkanStream* vkStream,
+ VkSamplerYcbcrConversionCreateInfo* forUnmarshaling);
+
+void marshal_VkSamplerYcbcrConversionInfo(
+ VulkanStream* vkStream,
+ const VkSamplerYcbcrConversionInfo* forMarshaling);
+
+void unmarshal_VkSamplerYcbcrConversionInfo(
+ VulkanStream* vkStream,
+ VkSamplerYcbcrConversionInfo* forUnmarshaling);
+
+void marshal_VkBindImagePlaneMemoryInfo(
+ VulkanStream* vkStream,
+ const VkBindImagePlaneMemoryInfo* forMarshaling);
+
+void unmarshal_VkBindImagePlaneMemoryInfo(
+ VulkanStream* vkStream,
+ VkBindImagePlaneMemoryInfo* forUnmarshaling);
+
+void marshal_VkImagePlaneMemoryRequirementsInfo(
+ VulkanStream* vkStream,
+ const VkImagePlaneMemoryRequirementsInfo* forMarshaling);
+
+void unmarshal_VkImagePlaneMemoryRequirementsInfo(
+ VulkanStream* vkStream,
+ VkImagePlaneMemoryRequirementsInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling);
+
+void marshal_VkSamplerYcbcrConversionImageFormatProperties(
+ VulkanStream* vkStream,
+ const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling);
+
+void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
+ VulkanStream* vkStream,
+ VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling);
+
+#define OP_vkCreateSamplerYcbcrConversion 20156
+#define OP_vkDestroySamplerYcbcrConversion 20157
+void marshal_VkDescriptorUpdateTemplateEntry(
+ VulkanStream* vkStream,
+ const VkDescriptorUpdateTemplateEntry* forMarshaling);
+
+void unmarshal_VkDescriptorUpdateTemplateEntry(
+ VulkanStream* vkStream,
+ VkDescriptorUpdateTemplateEntry* forUnmarshaling);
+
+void marshal_VkDescriptorUpdateTemplateCreateInfo(
+ VulkanStream* vkStream,
+ const VkDescriptorUpdateTemplateCreateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
+ VulkanStream* vkStream,
+ VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling);
+
+#define OP_vkCreateDescriptorUpdateTemplate 20158
+#define OP_vkDestroyDescriptorUpdateTemplate 20159
+#define OP_vkUpdateDescriptorSetWithTemplate 20160
+void marshal_VkExternalMemoryProperties(
+ VulkanStream* vkStream,
+ const VkExternalMemoryProperties* forMarshaling);
+
+void unmarshal_VkExternalMemoryProperties(
+ VulkanStream* vkStream,
+ VkExternalMemoryProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalImageFormatInfo(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling);
+
+void marshal_VkExternalImageFormatProperties(
+ VulkanStream* vkStream,
+ const VkExternalImageFormatProperties* forMarshaling);
+
+void unmarshal_VkExternalImageFormatProperties(
+ VulkanStream* vkStream,
+ VkExternalImageFormatProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalBufferInfo(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalBufferInfo* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalBufferInfo(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalBufferInfo* forUnmarshaling);
+
+void marshal_VkExternalBufferProperties(
+ VulkanStream* vkStream,
+ const VkExternalBufferProperties* forMarshaling);
+
+void unmarshal_VkExternalBufferProperties(
+ VulkanStream* vkStream,
+ VkExternalBufferProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceIDProperties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceIDProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceIDProperties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceIDProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceExternalBufferProperties 20161
+void marshal_VkExternalMemoryImageCreateInfo(
+ VulkanStream* vkStream,
+ const VkExternalMemoryImageCreateInfo* forMarshaling);
+
+void unmarshal_VkExternalMemoryImageCreateInfo(
+ VulkanStream* vkStream,
+ VkExternalMemoryImageCreateInfo* forUnmarshaling);
+
+void marshal_VkExternalMemoryBufferCreateInfo(
+ VulkanStream* vkStream,
+ const VkExternalMemoryBufferCreateInfo* forMarshaling);
+
+void unmarshal_VkExternalMemoryBufferCreateInfo(
+ VulkanStream* vkStream,
+ VkExternalMemoryBufferCreateInfo* forUnmarshaling);
+
+void marshal_VkExportMemoryAllocateInfo(
+ VulkanStream* vkStream,
+ const VkExportMemoryAllocateInfo* forMarshaling);
+
+void unmarshal_VkExportMemoryAllocateInfo(
+ VulkanStream* vkStream,
+ VkExportMemoryAllocateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalFenceInfo(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalFenceInfo* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalFenceInfo(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalFenceInfo* forUnmarshaling);
+
+void marshal_VkExternalFenceProperties(
+ VulkanStream* vkStream,
+ const VkExternalFenceProperties* forMarshaling);
+
+void unmarshal_VkExternalFenceProperties(
+ VulkanStream* vkStream,
+ VkExternalFenceProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceExternalFenceProperties 20162
+void marshal_VkExportFenceCreateInfo(
+ VulkanStream* vkStream,
+ const VkExportFenceCreateInfo* forMarshaling);
+
+void unmarshal_VkExportFenceCreateInfo(
+ VulkanStream* vkStream,
+ VkExportFenceCreateInfo* forUnmarshaling);
+
+void marshal_VkExportSemaphoreCreateInfo(
+ VulkanStream* vkStream,
+ const VkExportSemaphoreCreateInfo* forMarshaling);
+
+void unmarshal_VkExportSemaphoreCreateInfo(
+ VulkanStream* vkStream,
+ VkExportSemaphoreCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling);
+
+void marshal_VkExternalSemaphoreProperties(
+ VulkanStream* vkStream,
+ const VkExternalSemaphoreProperties* forMarshaling);
+
+void unmarshal_VkExternalSemaphoreProperties(
+ VulkanStream* vkStream,
+ VkExternalSemaphoreProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceExternalSemaphoreProperties 20163
+void marshal_VkPhysicalDeviceMaintenance3Properties(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMaintenance3Properties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance3Properties(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMaintenance3Properties* forUnmarshaling);
+
+void marshal_VkDescriptorSetLayoutSupport(
+ VulkanStream* vkStream,
+ const VkDescriptorSetLayoutSupport* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutSupport(
+ VulkanStream* vkStream,
+ VkDescriptorSetLayoutSupport* forUnmarshaling);
+
+#define OP_vkGetDescriptorSetLayoutSupport 20164
+void marshal_VkPhysicalDeviceShaderDrawParameterFeatures(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceShaderDrawParameterFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceShaderDrawParameterFeatures* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_surface
+#define OP_vkDestroySurfaceKHR 20165
+#define OP_vkGetPhysicalDeviceSurfaceSupportKHR 20166
+void marshal_VkSurfaceCapabilitiesKHR(
+ VulkanStream* vkStream,
+ const VkSurfaceCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkSurfaceCapabilitiesKHR(
+ VulkanStream* vkStream,
+ VkSurfaceCapabilitiesKHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR 20167
+void marshal_VkSurfaceFormatKHR(
+ VulkanStream* vkStream,
+ const VkSurfaceFormatKHR* forMarshaling);
+
+void unmarshal_VkSurfaceFormatKHR(
+ VulkanStream* vkStream,
+ VkSurfaceFormatKHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceSurfaceFormatsKHR 20168
+#define OP_vkGetPhysicalDeviceSurfacePresentModesKHR 20169
+#endif
+#ifdef VK_KHR_swapchain
+void marshal_VkSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkSwapchainCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkSwapchainCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateSwapchainKHR 20170
+#define OP_vkDestroySwapchainKHR 20171
+#define OP_vkGetSwapchainImagesKHR 20172
+#define OP_vkAcquireNextImageKHR 20173
+void marshal_VkPresentInfoKHR(
+ VulkanStream* vkStream,
+ const VkPresentInfoKHR* forMarshaling);
+
+void unmarshal_VkPresentInfoKHR(
+ VulkanStream* vkStream,
+ VkPresentInfoKHR* forUnmarshaling);
+
+#define OP_vkQueuePresentKHR 20174
+void marshal_VkImageSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkImageSwapchainCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkImageSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkImageSwapchainCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkBindImageMemorySwapchainInfoKHR(
+ VulkanStream* vkStream,
+ const VkBindImageMemorySwapchainInfoKHR* forMarshaling);
+
+void unmarshal_VkBindImageMemorySwapchainInfoKHR(
+ VulkanStream* vkStream,
+ VkBindImageMemorySwapchainInfoKHR* forUnmarshaling);
+
+void marshal_VkAcquireNextImageInfoKHR(
+ VulkanStream* vkStream,
+ const VkAcquireNextImageInfoKHR* forMarshaling);
+
+void unmarshal_VkAcquireNextImageInfoKHR(
+ VulkanStream* vkStream,
+ VkAcquireNextImageInfoKHR* forUnmarshaling);
+
+void marshal_VkDeviceGroupPresentCapabilitiesKHR(
+ VulkanStream* vkStream,
+ const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
+ VulkanStream* vkStream,
+ VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling);
+
+void marshal_VkDeviceGroupPresentInfoKHR(
+ VulkanStream* vkStream,
+ const VkDeviceGroupPresentInfoKHR* forMarshaling);
+
+void unmarshal_VkDeviceGroupPresentInfoKHR(
+ VulkanStream* vkStream,
+ VkDeviceGroupPresentInfoKHR* forUnmarshaling);
+
+void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkGetDeviceGroupPresentCapabilitiesKHR 20175
+#define OP_vkGetDeviceGroupSurfacePresentModesKHR 20176
+#define OP_vkGetPhysicalDevicePresentRectanglesKHR 20177
+#define OP_vkAcquireNextImage2KHR 20178
+#endif
+#ifdef VK_KHR_display
+void marshal_VkDisplayPropertiesKHR(
+ VulkanStream* vkStream,
+ const VkDisplayPropertiesKHR* forMarshaling);
+
+void unmarshal_VkDisplayPropertiesKHR(
+ VulkanStream* vkStream,
+ VkDisplayPropertiesKHR* forUnmarshaling);
+
+void marshal_VkDisplayModeParametersKHR(
+ VulkanStream* vkStream,
+ const VkDisplayModeParametersKHR* forMarshaling);
+
+void unmarshal_VkDisplayModeParametersKHR(
+ VulkanStream* vkStream,
+ VkDisplayModeParametersKHR* forUnmarshaling);
+
+void marshal_VkDisplayModePropertiesKHR(
+ VulkanStream* vkStream,
+ const VkDisplayModePropertiesKHR* forMarshaling);
+
+void unmarshal_VkDisplayModePropertiesKHR(
+ VulkanStream* vkStream,
+ VkDisplayModePropertiesKHR* forUnmarshaling);
+
+void marshal_VkDisplayModeCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkDisplayModeCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkDisplayModeCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkDisplayModeCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkDisplayPlaneCapabilitiesKHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlaneCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkDisplayPlaneCapabilitiesKHR(
+ VulkanStream* vkStream,
+ VkDisplayPlaneCapabilitiesKHR* forUnmarshaling);
+
+void marshal_VkDisplayPlanePropertiesKHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlanePropertiesKHR* forMarshaling);
+
+void unmarshal_VkDisplayPlanePropertiesKHR(
+ VulkanStream* vkStream,
+ VkDisplayPlanePropertiesKHR* forUnmarshaling);
+
+void marshal_VkDisplaySurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkDisplaySurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkDisplaySurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkDisplaySurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceDisplayPropertiesKHR 20179
+#define OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR 20180
+#define OP_vkGetDisplayPlaneSupportedDisplaysKHR 20181
+#define OP_vkGetDisplayModePropertiesKHR 20182
+#define OP_vkCreateDisplayModeKHR 20183
+#define OP_vkGetDisplayPlaneCapabilitiesKHR 20184
+#define OP_vkCreateDisplayPlaneSurfaceKHR 20185
+#endif
+#ifdef VK_KHR_display_swapchain
+void marshal_VkDisplayPresentInfoKHR(
+ VulkanStream* vkStream,
+ const VkDisplayPresentInfoKHR* forMarshaling);
+
+void unmarshal_VkDisplayPresentInfoKHR(
+ VulkanStream* vkStream,
+ VkDisplayPresentInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateSharedSwapchainsKHR 20186
+#endif
+#ifdef VK_KHR_xlib_surface
+void marshal_VkXlibSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkXlibSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkXlibSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkXlibSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateXlibSurfaceKHR 20187
+#define OP_vkGetPhysicalDeviceXlibPresentationSupportKHR 20188
+#endif
+#ifdef VK_KHR_xcb_surface
+void marshal_VkXcbSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkXcbSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkXcbSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkXcbSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateXcbSurfaceKHR 20189
+#define OP_vkGetPhysicalDeviceXcbPresentationSupportKHR 20190
+#endif
+#ifdef VK_KHR_wayland_surface
+void marshal_VkWaylandSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkWaylandSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkWaylandSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkWaylandSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateWaylandSurfaceKHR 20191
+#define OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR 20192
+#endif
+#ifdef VK_KHR_mir_surface
+void marshal_VkMirSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkMirSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkMirSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkMirSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateMirSurfaceKHR 20193
+#define OP_vkGetPhysicalDeviceMirPresentationSupportKHR 20194
+#endif
+#ifdef VK_KHR_android_surface
+void marshal_VkAndroidSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkAndroidSurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkAndroidSurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkAndroidSurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateAndroidSurfaceKHR 20195
+#endif
+#ifdef VK_KHR_win32_surface
+void marshal_VkWin32SurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkWin32SurfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkWin32SurfaceCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkWin32SurfaceCreateInfoKHR* forUnmarshaling);
+
+#define OP_vkCreateWin32SurfaceKHR 20196
+#define OP_vkGetPhysicalDeviceWin32PresentationSupportKHR 20197
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#define OP_vkGetPhysicalDeviceFeatures2KHR 20198
+#define OP_vkGetPhysicalDeviceProperties2KHR 20199
+#define OP_vkGetPhysicalDeviceFormatProperties2KHR 20200
+#define OP_vkGetPhysicalDeviceImageFormatProperties2KHR 20201
+#define OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR 20202
+#define OP_vkGetPhysicalDeviceMemoryProperties2KHR 20203
+#define OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR 20204
+#endif
+#ifdef VK_KHR_device_group
+#define OP_vkGetDeviceGroupPeerMemoryFeaturesKHR 20205
+#define OP_vkCmdSetDeviceMaskKHR 20206
+#define OP_vkCmdDispatchBaseKHR 20207
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#define OP_vkTrimCommandPoolKHR 20208
+#endif
+#ifdef VK_KHR_device_group_creation
+#define OP_vkEnumeratePhysicalDeviceGroupsKHR 20209
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#define OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR 20210
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+void marshal_VkImportMemoryWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportMemoryWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkImportMemoryWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkImportMemoryWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkExportMemoryWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkExportMemoryWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkExportMemoryWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkExportMemoryWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkMemoryWin32HandlePropertiesKHR(
+ VulkanStream* vkStream,
+ const VkMemoryWin32HandlePropertiesKHR* forMarshaling);
+
+void unmarshal_VkMemoryWin32HandlePropertiesKHR(
+ VulkanStream* vkStream,
+ VkMemoryWin32HandlePropertiesKHR* forUnmarshaling);
+
+void marshal_VkMemoryGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkMemoryGetWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkMemoryGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkMemoryGetWin32HandleInfoKHR* forUnmarshaling);
+
+#define OP_vkGetMemoryWin32HandleKHR 20211
+#define OP_vkGetMemoryWin32HandlePropertiesKHR 20212
+#endif
+#ifdef VK_KHR_external_memory_fd
+void marshal_VkImportMemoryFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportMemoryFdInfoKHR* forMarshaling);
+
+void unmarshal_VkImportMemoryFdInfoKHR(
+ VulkanStream* vkStream,
+ VkImportMemoryFdInfoKHR* forUnmarshaling);
+
+void marshal_VkMemoryFdPropertiesKHR(
+ VulkanStream* vkStream,
+ const VkMemoryFdPropertiesKHR* forMarshaling);
+
+void unmarshal_VkMemoryFdPropertiesKHR(
+ VulkanStream* vkStream,
+ VkMemoryFdPropertiesKHR* forUnmarshaling);
+
+void marshal_VkMemoryGetFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkMemoryGetFdInfoKHR* forMarshaling);
+
+void unmarshal_VkMemoryGetFdInfoKHR(
+ VulkanStream* vkStream,
+ VkMemoryGetFdInfoKHR* forUnmarshaling);
+
+#define OP_vkGetMemoryFdKHR 20213
+#define OP_vkGetMemoryFdPropertiesKHR 20214
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ VulkanStream* vkStream,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling);
+
+void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ VulkanStream* vkStream,
+ VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#define OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR 20215
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+void marshal_VkImportSemaphoreWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkExportSemaphoreWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkD3D12FenceSubmitInfoKHR(
+ VulkanStream* vkStream,
+ const VkD3D12FenceSubmitInfoKHR* forMarshaling);
+
+void unmarshal_VkD3D12FenceSubmitInfoKHR(
+ VulkanStream* vkStream,
+ VkD3D12FenceSubmitInfoKHR* forUnmarshaling);
+
+void marshal_VkSemaphoreGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling);
+
+#define OP_vkImportSemaphoreWin32HandleKHR 20216
+#define OP_vkGetSemaphoreWin32HandleKHR 20217
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+void marshal_VkImportSemaphoreFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportSemaphoreFdInfoKHR* forMarshaling);
+
+void unmarshal_VkImportSemaphoreFdInfoKHR(
+ VulkanStream* vkStream,
+ VkImportSemaphoreFdInfoKHR* forUnmarshaling);
+
+void marshal_VkSemaphoreGetFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkSemaphoreGetFdInfoKHR* forMarshaling);
+
+void unmarshal_VkSemaphoreGetFdInfoKHR(
+ VulkanStream* vkStream,
+ VkSemaphoreGetFdInfoKHR* forUnmarshaling);
+
+#define OP_vkImportSemaphoreFdKHR 20218
+#define OP_vkGetSemaphoreFdKHR 20219
+#endif
+#ifdef VK_KHR_push_descriptor
+void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ VulkanStream* vkStream,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ VulkanStream* vkStream,
+ VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling);
+
+#define OP_vkCmdPushDescriptorSetKHR 20220
+#define OP_vkCmdPushDescriptorSetWithTemplateKHR 20221
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+void marshal_VkRectLayerKHR(
+ VulkanStream* vkStream,
+ const VkRectLayerKHR* forMarshaling);
+
+void unmarshal_VkRectLayerKHR(
+ VulkanStream* vkStream,
+ VkRectLayerKHR* forUnmarshaling);
+
+void marshal_VkPresentRegionKHR(
+ VulkanStream* vkStream,
+ const VkPresentRegionKHR* forMarshaling);
+
+void unmarshal_VkPresentRegionKHR(
+ VulkanStream* vkStream,
+ VkPresentRegionKHR* forUnmarshaling);
+
+void marshal_VkPresentRegionsKHR(
+ VulkanStream* vkStream,
+ const VkPresentRegionsKHR* forMarshaling);
+
+void unmarshal_VkPresentRegionsKHR(
+ VulkanStream* vkStream,
+ VkPresentRegionsKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#define OP_vkCreateDescriptorUpdateTemplateKHR 20222
+#define OP_vkDestroyDescriptorUpdateTemplateKHR 20223
+#define OP_vkUpdateDescriptorSetWithTemplateKHR 20224
+#endif
+#ifdef VK_KHR_create_renderpass2
+void marshal_VkAttachmentDescription2KHR(
+ VulkanStream* vkStream,
+ const VkAttachmentDescription2KHR* forMarshaling);
+
+void unmarshal_VkAttachmentDescription2KHR(
+ VulkanStream* vkStream,
+ VkAttachmentDescription2KHR* forUnmarshaling);
+
+void marshal_VkAttachmentReference2KHR(
+ VulkanStream* vkStream,
+ const VkAttachmentReference2KHR* forMarshaling);
+
+void unmarshal_VkAttachmentReference2KHR(
+ VulkanStream* vkStream,
+ VkAttachmentReference2KHR* forUnmarshaling);
+
+void marshal_VkSubpassDescription2KHR(
+ VulkanStream* vkStream,
+ const VkSubpassDescription2KHR* forMarshaling);
+
+void unmarshal_VkSubpassDescription2KHR(
+ VulkanStream* vkStream,
+ VkSubpassDescription2KHR* forUnmarshaling);
+
+void marshal_VkSubpassDependency2KHR(
+ VulkanStream* vkStream,
+ const VkSubpassDependency2KHR* forMarshaling);
+
+void unmarshal_VkSubpassDependency2KHR(
+ VulkanStream* vkStream,
+ VkSubpassDependency2KHR* forUnmarshaling);
+
+void marshal_VkRenderPassCreateInfo2KHR(
+ VulkanStream* vkStream,
+ const VkRenderPassCreateInfo2KHR* forMarshaling);
+
+void unmarshal_VkRenderPassCreateInfo2KHR(
+ VulkanStream* vkStream,
+ VkRenderPassCreateInfo2KHR* forUnmarshaling);
+
+#define OP_vkCreateRenderPass2KHR 20225
+void marshal_VkSubpassBeginInfoKHR(
+ VulkanStream* vkStream,
+ const VkSubpassBeginInfoKHR* forMarshaling);
+
+void unmarshal_VkSubpassBeginInfoKHR(
+ VulkanStream* vkStream,
+ VkSubpassBeginInfoKHR* forUnmarshaling);
+
+#define OP_vkCmdBeginRenderPass2KHR 20226
+void marshal_VkSubpassEndInfoKHR(
+ VulkanStream* vkStream,
+ const VkSubpassEndInfoKHR* forMarshaling);
+
+void unmarshal_VkSubpassEndInfoKHR(
+ VulkanStream* vkStream,
+ VkSubpassEndInfoKHR* forUnmarshaling);
+
+#define OP_vkCmdNextSubpass2KHR 20227
+#define OP_vkCmdEndRenderPass2KHR 20228
+#endif
+#ifdef VK_KHR_shared_presentable_image
+void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
+ VulkanStream* vkStream,
+ const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
+ VulkanStream* vkStream,
+ VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling);
+
+#define OP_vkGetSwapchainStatusKHR 20229
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#define OP_vkGetPhysicalDeviceExternalFencePropertiesKHR 20230
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+void marshal_VkImportFenceWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportFenceWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkImportFenceWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkImportFenceWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkExportFenceWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkExportFenceWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkExportFenceWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkExportFenceWin32HandleInfoKHR* forUnmarshaling);
+
+void marshal_VkFenceGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ const VkFenceGetWin32HandleInfoKHR* forMarshaling);
+
+void unmarshal_VkFenceGetWin32HandleInfoKHR(
+ VulkanStream* vkStream,
+ VkFenceGetWin32HandleInfoKHR* forUnmarshaling);
+
+#define OP_vkImportFenceWin32HandleKHR 20231
+#define OP_vkGetFenceWin32HandleKHR 20232
+#endif
+#ifdef VK_KHR_external_fence_fd
+void marshal_VkImportFenceFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkImportFenceFdInfoKHR* forMarshaling);
+
+void unmarshal_VkImportFenceFdInfoKHR(
+ VulkanStream* vkStream,
+ VkImportFenceFdInfoKHR* forUnmarshaling);
+
+void marshal_VkFenceGetFdInfoKHR(
+ VulkanStream* vkStream,
+ const VkFenceGetFdInfoKHR* forMarshaling);
+
+void unmarshal_VkFenceGetFdInfoKHR(
+ VulkanStream* vkStream,
+ VkFenceGetFdInfoKHR* forUnmarshaling);
+
+#define OP_vkImportFenceFdKHR 20233
+#define OP_vkGetFenceFdKHR 20234
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling);
+
+void marshal_VkSurfaceCapabilities2KHR(
+ VulkanStream* vkStream,
+ const VkSurfaceCapabilities2KHR* forMarshaling);
+
+void unmarshal_VkSurfaceCapabilities2KHR(
+ VulkanStream* vkStream,
+ VkSurfaceCapabilities2KHR* forUnmarshaling);
+
+void marshal_VkSurfaceFormat2KHR(
+ VulkanStream* vkStream,
+ const VkSurfaceFormat2KHR* forMarshaling);
+
+void unmarshal_VkSurfaceFormat2KHR(
+ VulkanStream* vkStream,
+ VkSurfaceFormat2KHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR 20235
+#define OP_vkGetPhysicalDeviceSurfaceFormats2KHR 20236
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+void marshal_VkDisplayProperties2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayProperties2KHR* forMarshaling);
+
+void unmarshal_VkDisplayProperties2KHR(
+ VulkanStream* vkStream,
+ VkDisplayProperties2KHR* forUnmarshaling);
+
+void marshal_VkDisplayPlaneProperties2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlaneProperties2KHR* forMarshaling);
+
+void unmarshal_VkDisplayPlaneProperties2KHR(
+ VulkanStream* vkStream,
+ VkDisplayPlaneProperties2KHR* forUnmarshaling);
+
+void marshal_VkDisplayModeProperties2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayModeProperties2KHR* forMarshaling);
+
+void unmarshal_VkDisplayModeProperties2KHR(
+ VulkanStream* vkStream,
+ VkDisplayModeProperties2KHR* forUnmarshaling);
+
+void marshal_VkDisplayPlaneInfo2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlaneInfo2KHR* forMarshaling);
+
+void unmarshal_VkDisplayPlaneInfo2KHR(
+ VulkanStream* vkStream,
+ VkDisplayPlaneInfo2KHR* forUnmarshaling);
+
+void marshal_VkDisplayPlaneCapabilities2KHR(
+ VulkanStream* vkStream,
+ const VkDisplayPlaneCapabilities2KHR* forMarshaling);
+
+void unmarshal_VkDisplayPlaneCapabilities2KHR(
+ VulkanStream* vkStream,
+ VkDisplayPlaneCapabilities2KHR* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceDisplayProperties2KHR 20237
+#define OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR 20238
+#define OP_vkGetDisplayModeProperties2KHR 20239
+#define OP_vkGetDisplayPlaneCapabilities2KHR 20240
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#define OP_vkGetImageMemoryRequirements2KHR 20241
+#define OP_vkGetBufferMemoryRequirements2KHR 20242
+#define OP_vkGetImageSparseMemoryRequirements2KHR 20243
+#endif
+#ifdef VK_KHR_image_format_list
+void marshal_VkImageFormatListCreateInfoKHR(
+ VulkanStream* vkStream,
+ const VkImageFormatListCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkImageFormatListCreateInfoKHR(
+ VulkanStream* vkStream,
+ VkImageFormatListCreateInfoKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#define OP_vkCreateSamplerYcbcrConversionKHR 20244
+#define OP_vkDestroySamplerYcbcrConversionKHR 20245
+#endif
+#ifdef VK_KHR_bind_memory2
+#define OP_vkBindBufferMemory2KHR 20246
+#define OP_vkBindImageMemory2KHR 20247
+#endif
+#ifdef VK_KHR_maintenance3
+#define OP_vkGetDescriptorSetLayoutSupportKHR 20248
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#define OP_vkCmdDrawIndirectCountKHR 20249
+#define OP_vkCmdDrawIndexedIndirectCountKHR 20250
+#endif
+#ifdef VK_KHR_8bit_storage
+void marshal_VkPhysicalDevice8BitStorageFeaturesKHR(
+ VulkanStream* vkStream,
+ const VkPhysicalDevice8BitStorageFeaturesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR(
+ VulkanStream* vkStream,
+ VkPhysicalDevice8BitStorageFeaturesKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_ANDROID_native_buffer
+void marshal_VkNativeBufferANDROID(
+ VulkanStream* vkStream,
+ const VkNativeBufferANDROID* forMarshaling);
+
+void unmarshal_VkNativeBufferANDROID(
+ VulkanStream* vkStream,
+ VkNativeBufferANDROID* forUnmarshaling);
+
+#define OP_vkGetSwapchainGrallocUsageANDROID 20251
+#define OP_vkAcquireImageANDROID 20252
+#define OP_vkQueueSignalReleaseImageANDROID 20253
+#endif
+#ifdef VK_EXT_debug_report
+void marshal_VkDebugReportCallbackCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugReportCallbackCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugReportCallbackCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugReportCallbackCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkCreateDebugReportCallbackEXT 20254
+#define OP_vkDestroyDebugReportCallbackEXT 20255
+#define OP_vkDebugReportMessageEXT 20256
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+ VulkanStream* vkStream,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+ VulkanStream* vkStream,
+ VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+void marshal_VkDebugMarkerObjectNameInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugMarkerObjectNameInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugMarkerObjectNameInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugMarkerObjectNameInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugMarkerObjectTagInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugMarkerObjectTagInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugMarkerObjectTagInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugMarkerObjectTagInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugMarkerMarkerInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugMarkerMarkerInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugMarkerMarkerInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugMarkerMarkerInfoEXT* forUnmarshaling);
+
+#define OP_vkDebugMarkerSetObjectTagEXT 20257
+#define OP_vkDebugMarkerSetObjectNameEXT 20258
+#define OP_vkCmdDebugMarkerBeginEXT 20259
+#define OP_vkCmdDebugMarkerEndEXT 20260
+#define OP_vkCmdDebugMarkerInsertEXT 20261
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+void marshal_VkDedicatedAllocationImageCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkDedicatedAllocationImageCreateInfoNV* forMarshaling);
+
+void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
+ VulkanStream* vkStream,
+ VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling);
+
+void marshal_VkDedicatedAllocationBufferCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling);
+
+void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
+ VulkanStream* vkStream,
+ VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling);
+
+void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+ VulkanStream* vkStream,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling);
+
+void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+ VulkanStream* vkStream,
+ VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#define OP_vkCmdDrawIndirectCountAMD 20262
+#define OP_vkCmdDrawIndexedIndirectCountAMD 20263
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+void marshal_VkTextureLODGatherFormatPropertiesAMD(
+ VulkanStream* vkStream,
+ const VkTextureLODGatherFormatPropertiesAMD* forMarshaling);
+
+void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
+ VulkanStream* vkStream,
+ VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_shader_info
+void marshal_VkShaderResourceUsageAMD(
+ VulkanStream* vkStream,
+ const VkShaderResourceUsageAMD* forMarshaling);
+
+void unmarshal_VkShaderResourceUsageAMD(
+ VulkanStream* vkStream,
+ VkShaderResourceUsageAMD* forUnmarshaling);
+
+void marshal_VkShaderStatisticsInfoAMD(
+ VulkanStream* vkStream,
+ const VkShaderStatisticsInfoAMD* forMarshaling);
+
+void unmarshal_VkShaderStatisticsInfoAMD(
+ VulkanStream* vkStream,
+ VkShaderStatisticsInfoAMD* forUnmarshaling);
+
+#define OP_vkGetShaderInfoAMD 20264
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+void marshal_VkExternalImageFormatPropertiesNV(
+ VulkanStream* vkStream,
+ const VkExternalImageFormatPropertiesNV* forMarshaling);
+
+void unmarshal_VkExternalImageFormatPropertiesNV(
+ VulkanStream* vkStream,
+ VkExternalImageFormatPropertiesNV* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV 20265
+#endif
+#ifdef VK_NV_external_memory
+void marshal_VkExternalMemoryImageCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkExternalMemoryImageCreateInfoNV* forMarshaling);
+
+void unmarshal_VkExternalMemoryImageCreateInfoNV(
+ VulkanStream* vkStream,
+ VkExternalMemoryImageCreateInfoNV* forUnmarshaling);
+
+void marshal_VkExportMemoryAllocateInfoNV(
+ VulkanStream* vkStream,
+ const VkExportMemoryAllocateInfoNV* forMarshaling);
+
+void unmarshal_VkExportMemoryAllocateInfoNV(
+ VulkanStream* vkStream,
+ VkExportMemoryAllocateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_external_memory_win32
+void marshal_VkImportMemoryWin32HandleInfoNV(
+ VulkanStream* vkStream,
+ const VkImportMemoryWin32HandleInfoNV* forMarshaling);
+
+void unmarshal_VkImportMemoryWin32HandleInfoNV(
+ VulkanStream* vkStream,
+ VkImportMemoryWin32HandleInfoNV* forUnmarshaling);
+
+void marshal_VkExportMemoryWin32HandleInfoNV(
+ VulkanStream* vkStream,
+ const VkExportMemoryWin32HandleInfoNV* forMarshaling);
+
+void unmarshal_VkExportMemoryWin32HandleInfoNV(
+ VulkanStream* vkStream,
+ VkExportMemoryWin32HandleInfoNV* forUnmarshaling);
+
+#define OP_vkGetMemoryWin32HandleNV 20266
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ VulkanStream* vkStream,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling);
+
+void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ VulkanStream* vkStream,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_validation_flags
+void marshal_VkValidationFlagsEXT(
+ VulkanStream* vkStream,
+ const VkValidationFlagsEXT* forMarshaling);
+
+void unmarshal_VkValidationFlagsEXT(
+ VulkanStream* vkStream,
+ VkValidationFlagsEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_NN_vi_surface
+void marshal_VkViSurfaceCreateInfoNN(
+ VulkanStream* vkStream,
+ const VkViSurfaceCreateInfoNN* forMarshaling);
+
+void unmarshal_VkViSurfaceCreateInfoNN(
+ VulkanStream* vkStream,
+ VkViSurfaceCreateInfoNN* forUnmarshaling);
+
+#define OP_vkCreateViSurfaceNN 20267
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void marshal_VkConditionalRenderingBeginInfoEXT(
+ VulkanStream* vkStream,
+ const VkConditionalRenderingBeginInfoEXT* forMarshaling);
+
+void unmarshal_VkConditionalRenderingBeginInfoEXT(
+ VulkanStream* vkStream,
+ VkConditionalRenderingBeginInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling);
+
+void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ VulkanStream* vkStream,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling);
+
+void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ VulkanStream* vkStream,
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling);
+
+#define OP_vkCmdBeginConditionalRenderingEXT 20268
+#define OP_vkCmdEndConditionalRenderingEXT 20269
+#endif
+#ifdef VK_NVX_device_generated_commands
+void marshal_VkDeviceGeneratedCommandsFeaturesNVX(
+ VulkanStream* vkStream,
+ const VkDeviceGeneratedCommandsFeaturesNVX* forMarshaling);
+
+void unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(
+ VulkanStream* vkStream,
+ VkDeviceGeneratedCommandsFeaturesNVX* forUnmarshaling);
+
+void marshal_VkDeviceGeneratedCommandsLimitsNVX(
+ VulkanStream* vkStream,
+ const VkDeviceGeneratedCommandsLimitsNVX* forMarshaling);
+
+void unmarshal_VkDeviceGeneratedCommandsLimitsNVX(
+ VulkanStream* vkStream,
+ VkDeviceGeneratedCommandsLimitsNVX* forUnmarshaling);
+
+void marshal_VkIndirectCommandsTokenNVX(
+ VulkanStream* vkStream,
+ const VkIndirectCommandsTokenNVX* forMarshaling);
+
+void unmarshal_VkIndirectCommandsTokenNVX(
+ VulkanStream* vkStream,
+ VkIndirectCommandsTokenNVX* forUnmarshaling);
+
+void marshal_VkIndirectCommandsLayoutTokenNVX(
+ VulkanStream* vkStream,
+ const VkIndirectCommandsLayoutTokenNVX* forMarshaling);
+
+void unmarshal_VkIndirectCommandsLayoutTokenNVX(
+ VulkanStream* vkStream,
+ VkIndirectCommandsLayoutTokenNVX* forUnmarshaling);
+
+void marshal_VkIndirectCommandsLayoutCreateInfoNVX(
+ VulkanStream* vkStream,
+ const VkIndirectCommandsLayoutCreateInfoNVX* forMarshaling);
+
+void unmarshal_VkIndirectCommandsLayoutCreateInfoNVX(
+ VulkanStream* vkStream,
+ VkIndirectCommandsLayoutCreateInfoNVX* forUnmarshaling);
+
+void marshal_VkCmdProcessCommandsInfoNVX(
+ VulkanStream* vkStream,
+ const VkCmdProcessCommandsInfoNVX* forMarshaling);
+
+void unmarshal_VkCmdProcessCommandsInfoNVX(
+ VulkanStream* vkStream,
+ VkCmdProcessCommandsInfoNVX* forUnmarshaling);
+
+void marshal_VkCmdReserveSpaceForCommandsInfoNVX(
+ VulkanStream* vkStream,
+ const VkCmdReserveSpaceForCommandsInfoNVX* forMarshaling);
+
+void unmarshal_VkCmdReserveSpaceForCommandsInfoNVX(
+ VulkanStream* vkStream,
+ VkCmdReserveSpaceForCommandsInfoNVX* forUnmarshaling);
+
+void marshal_VkObjectTableCreateInfoNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableCreateInfoNVX* forMarshaling);
+
+void unmarshal_VkObjectTableCreateInfoNVX(
+ VulkanStream* vkStream,
+ VkObjectTableCreateInfoNVX* forUnmarshaling);
+
+void marshal_VkObjectTableEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTableEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTableEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTablePipelineEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTablePipelineEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTablePipelineEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTablePipelineEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTableDescriptorSetEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableDescriptorSetEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTableDescriptorSetEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTableDescriptorSetEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTableVertexBufferEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableVertexBufferEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTableVertexBufferEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTableVertexBufferEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTableIndexBufferEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTableIndexBufferEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTableIndexBufferEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTableIndexBufferEntryNVX* forUnmarshaling);
+
+void marshal_VkObjectTablePushConstantEntryNVX(
+ VulkanStream* vkStream,
+ const VkObjectTablePushConstantEntryNVX* forMarshaling);
+
+void unmarshal_VkObjectTablePushConstantEntryNVX(
+ VulkanStream* vkStream,
+ VkObjectTablePushConstantEntryNVX* forUnmarshaling);
+
+#define OP_vkCmdProcessCommandsNVX 20270
+#define OP_vkCmdReserveSpaceForCommandsNVX 20271
+#define OP_vkCreateIndirectCommandsLayoutNVX 20272
+#define OP_vkDestroyIndirectCommandsLayoutNVX 20273
+#define OP_vkCreateObjectTableNVX 20274
+#define OP_vkDestroyObjectTableNVX 20275
+#define OP_vkRegisterObjectsNVX 20276
+#define OP_vkUnregisterObjectsNVX 20277
+#define OP_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX 20278
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void marshal_VkViewportWScalingNV(
+ VulkanStream* vkStream,
+ const VkViewportWScalingNV* forMarshaling);
+
+void unmarshal_VkViewportWScalingNV(
+ VulkanStream* vkStream,
+ VkViewportWScalingNV* forUnmarshaling);
+
+void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling);
+
+void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
+ VulkanStream* vkStream,
+ VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling);
+
+#define OP_vkCmdSetViewportWScalingNV 20279
+#endif
+#ifdef VK_EXT_direct_mode_display
+#define OP_vkReleaseDisplayEXT 20280
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#define OP_vkAcquireXlibDisplayEXT 20281
+#define OP_vkGetRandROutputDisplayEXT 20282
+#endif
+#ifdef VK_EXT_display_surface_counter
+void marshal_VkSurfaceCapabilities2EXT(
+ VulkanStream* vkStream,
+ const VkSurfaceCapabilities2EXT* forMarshaling);
+
+void unmarshal_VkSurfaceCapabilities2EXT(
+ VulkanStream* vkStream,
+ VkSurfaceCapabilities2EXT* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT 20283
+#endif
+#ifdef VK_EXT_display_control
+void marshal_VkDisplayPowerInfoEXT(
+ VulkanStream* vkStream,
+ const VkDisplayPowerInfoEXT* forMarshaling);
+
+void unmarshal_VkDisplayPowerInfoEXT(
+ VulkanStream* vkStream,
+ VkDisplayPowerInfoEXT* forUnmarshaling);
+
+void marshal_VkDeviceEventInfoEXT(
+ VulkanStream* vkStream,
+ const VkDeviceEventInfoEXT* forMarshaling);
+
+void unmarshal_VkDeviceEventInfoEXT(
+ VulkanStream* vkStream,
+ VkDeviceEventInfoEXT* forUnmarshaling);
+
+void marshal_VkDisplayEventInfoEXT(
+ VulkanStream* vkStream,
+ const VkDisplayEventInfoEXT* forMarshaling);
+
+void unmarshal_VkDisplayEventInfoEXT(
+ VulkanStream* vkStream,
+ VkDisplayEventInfoEXT* forUnmarshaling);
+
+void marshal_VkSwapchainCounterCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkSwapchainCounterCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkSwapchainCounterCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkSwapchainCounterCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkDisplayPowerControlEXT 20284
+#define OP_vkRegisterDeviceEventEXT 20285
+#define OP_vkRegisterDisplayEventEXT 20286
+#define OP_vkGetSwapchainCounterEXT 20287
+#endif
+#ifdef VK_GOOGLE_display_timing
+void marshal_VkRefreshCycleDurationGOOGLE(
+ VulkanStream* vkStream,
+ const VkRefreshCycleDurationGOOGLE* forMarshaling);
+
+void unmarshal_VkRefreshCycleDurationGOOGLE(
+ VulkanStream* vkStream,
+ VkRefreshCycleDurationGOOGLE* forUnmarshaling);
+
+void marshal_VkPastPresentationTimingGOOGLE(
+ VulkanStream* vkStream,
+ const VkPastPresentationTimingGOOGLE* forMarshaling);
+
+void unmarshal_VkPastPresentationTimingGOOGLE(
+ VulkanStream* vkStream,
+ VkPastPresentationTimingGOOGLE* forUnmarshaling);
+
+void marshal_VkPresentTimeGOOGLE(
+ VulkanStream* vkStream,
+ const VkPresentTimeGOOGLE* forMarshaling);
+
+void unmarshal_VkPresentTimeGOOGLE(
+ VulkanStream* vkStream,
+ VkPresentTimeGOOGLE* forUnmarshaling);
+
+void marshal_VkPresentTimesInfoGOOGLE(
+ VulkanStream* vkStream,
+ const VkPresentTimesInfoGOOGLE* forMarshaling);
+
+void unmarshal_VkPresentTimesInfoGOOGLE(
+ VulkanStream* vkStream,
+ VkPresentTimesInfoGOOGLE* forUnmarshaling);
+
+#define OP_vkGetRefreshCycleDurationGOOGLE 20288
+#define OP_vkGetPastPresentationTimingGOOGLE 20289
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_viewport_swizzle
+void marshal_VkViewportSwizzleNV(
+ VulkanStream* vkStream,
+ const VkViewportSwizzleNV* forMarshaling);
+
+void unmarshal_VkViewportSwizzleNV(
+ VulkanStream* vkStream,
+ VkViewportSwizzleNV* forUnmarshaling);
+
+void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling);
+
+void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+ VulkanStream* vkStream,
+ VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_discard_rectangles
+void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling);
+
+void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkCmdSetDiscardRectangleEXT 20290
+#endif
+#ifdef VK_EXT_conservative_rasterization
+void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void marshal_VkXYColorEXT(
+ VulkanStream* vkStream,
+ const VkXYColorEXT* forMarshaling);
+
+void unmarshal_VkXYColorEXT(
+ VulkanStream* vkStream,
+ VkXYColorEXT* forUnmarshaling);
+
+void marshal_VkHdrMetadataEXT(
+ VulkanStream* vkStream,
+ const VkHdrMetadataEXT* forMarshaling);
+
+void unmarshal_VkHdrMetadataEXT(
+ VulkanStream* vkStream,
+ VkHdrMetadataEXT* forUnmarshaling);
+
+#define OP_vkSetHdrMetadataEXT 20291
+#endif
+#ifdef VK_MVK_ios_surface
+void marshal_VkIOSSurfaceCreateInfoMVK(
+ VulkanStream* vkStream,
+ const VkIOSSurfaceCreateInfoMVK* forMarshaling);
+
+void unmarshal_VkIOSSurfaceCreateInfoMVK(
+ VulkanStream* vkStream,
+ VkIOSSurfaceCreateInfoMVK* forUnmarshaling);
+
+#define OP_vkCreateIOSSurfaceMVK 20292
+#endif
+#ifdef VK_MVK_macos_surface
+void marshal_VkMacOSSurfaceCreateInfoMVK(
+ VulkanStream* vkStream,
+ const VkMacOSSurfaceCreateInfoMVK* forMarshaling);
+
+void unmarshal_VkMacOSSurfaceCreateInfoMVK(
+ VulkanStream* vkStream,
+ VkMacOSSurfaceCreateInfoMVK* forUnmarshaling);
+
+#define OP_vkCreateMacOSSurfaceMVK 20293
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+void marshal_VkDebugUtilsObjectNameInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsObjectNameInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsObjectNameInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsObjectNameInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsObjectTagInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsObjectTagInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsObjectTagInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsObjectTagInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsLabelEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsLabelEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsLabelEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsLabelEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkSetDebugUtilsObjectNameEXT 20294
+#define OP_vkSetDebugUtilsObjectTagEXT 20295
+#define OP_vkQueueBeginDebugUtilsLabelEXT 20296
+#define OP_vkQueueEndDebugUtilsLabelEXT 20297
+#define OP_vkQueueInsertDebugUtilsLabelEXT 20298
+#define OP_vkCmdBeginDebugUtilsLabelEXT 20299
+#define OP_vkCmdEndDebugUtilsLabelEXT 20300
+#define OP_vkCmdInsertDebugUtilsLabelEXT 20301
+#define OP_vkCreateDebugUtilsMessengerEXT 20302
+#define OP_vkDestroyDebugUtilsMessengerEXT 20303
+#define OP_vkSubmitDebugUtilsMessageEXT 20304
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+void marshal_VkAndroidHardwareBufferUsageANDROID(
+ VulkanStream* vkStream,
+ const VkAndroidHardwareBufferUsageANDROID* forMarshaling);
+
+void unmarshal_VkAndroidHardwareBufferUsageANDROID(
+ VulkanStream* vkStream,
+ VkAndroidHardwareBufferUsageANDROID* forUnmarshaling);
+
+void marshal_VkAndroidHardwareBufferPropertiesANDROID(
+ VulkanStream* vkStream,
+ const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling);
+
+void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
+ VulkanStream* vkStream,
+ VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling);
+
+void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ VulkanStream* vkStream,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling);
+
+void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ VulkanStream* vkStream,
+ VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling);
+
+void marshal_VkImportAndroidHardwareBufferInfoANDROID(
+ VulkanStream* vkStream,
+ const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling);
+
+void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
+ VulkanStream* vkStream,
+ VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling);
+
+void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ VulkanStream* vkStream,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling);
+
+void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ VulkanStream* vkStream,
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling);
+
+void marshal_VkExternalFormatANDROID(
+ VulkanStream* vkStream,
+ const VkExternalFormatANDROID* forMarshaling);
+
+void unmarshal_VkExternalFormatANDROID(
+ VulkanStream* vkStream,
+ VkExternalFormatANDROID* forUnmarshaling);
+
+#define OP_vkGetAndroidHardwareBufferPropertiesANDROID 20305
+#define OP_vkGetMemoryAndroidHardwareBufferANDROID 20306
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+void marshal_VkSamplerReductionModeCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkSamplerReductionModeCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkSamplerReductionModeCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkSamplerReductionModeCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void marshal_VkSampleLocationEXT(
+ VulkanStream* vkStream,
+ const VkSampleLocationEXT* forMarshaling);
+
+void unmarshal_VkSampleLocationEXT(
+ VulkanStream* vkStream,
+ VkSampleLocationEXT* forUnmarshaling);
+
+void marshal_VkSampleLocationsInfoEXT(
+ VulkanStream* vkStream,
+ const VkSampleLocationsInfoEXT* forMarshaling);
+
+void unmarshal_VkSampleLocationsInfoEXT(
+ VulkanStream* vkStream,
+ VkSampleLocationsInfoEXT* forUnmarshaling);
+
+void marshal_VkAttachmentSampleLocationsEXT(
+ VulkanStream* vkStream,
+ const VkAttachmentSampleLocationsEXT* forMarshaling);
+
+void unmarshal_VkAttachmentSampleLocationsEXT(
+ VulkanStream* vkStream,
+ VkAttachmentSampleLocationsEXT* forUnmarshaling);
+
+void marshal_VkSubpassSampleLocationsEXT(
+ VulkanStream* vkStream,
+ const VkSubpassSampleLocationsEXT* forMarshaling);
+
+void unmarshal_VkSubpassSampleLocationsEXT(
+ VulkanStream* vkStream,
+ VkSubpassSampleLocationsEXT* forUnmarshaling);
+
+void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
+ VulkanStream* vkStream,
+ const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling);
+
+void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
+ VulkanStream* vkStream,
+ VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling);
+
+void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling);
+
+void marshal_VkMultisamplePropertiesEXT(
+ VulkanStream* vkStream,
+ const VkMultisamplePropertiesEXT* forMarshaling);
+
+void unmarshal_VkMultisamplePropertiesEXT(
+ VulkanStream* vkStream,
+ VkMultisamplePropertiesEXT* forUnmarshaling);
+
+#define OP_vkCmdSetSampleLocationsEXT 20307
+#define OP_vkGetPhysicalDeviceMultisamplePropertiesEXT 20308
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling);
+
+void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
+ VulkanStream* vkStream,
+ VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
+ VulkanStream* vkStream,
+ const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling);
+
+void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
+ VulkanStream* vkStream,
+ VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+void marshal_VkValidationCacheCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkValidationCacheCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkValidationCacheCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkValidationCacheCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkCreateValidationCacheEXT 20309
+#define OP_vkDestroyValidationCacheEXT 20310
+#define OP_vkMergeValidationCachesEXT 20311
+#define OP_vkGetValidationCacheDataEXT 20312
+#endif
+#ifdef VK_EXT_descriptor_indexing
+void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceDescriptorIndexingFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceDescriptorIndexingPropertiesEXT* forUnmarshaling);
+
+void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forMarshaling);
+
+void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(
+ VulkanStream* vkStream,
+ VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* forUnmarshaling);
+
+void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+ VulkanStream* vkStream,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forMarshaling);
+
+void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(
+ VulkanStream* vkStream,
+ VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_external_memory_host
+void marshal_VkImportMemoryHostPointerInfoEXT(
+ VulkanStream* vkStream,
+ const VkImportMemoryHostPointerInfoEXT* forMarshaling);
+
+void unmarshal_VkImportMemoryHostPointerInfoEXT(
+ VulkanStream* vkStream,
+ VkImportMemoryHostPointerInfoEXT* forUnmarshaling);
+
+void marshal_VkMemoryHostPointerPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkMemoryHostPointerPropertiesEXT* forMarshaling);
+
+void unmarshal_VkMemoryHostPointerPropertiesEXT(
+ VulkanStream* vkStream,
+ VkMemoryHostPointerPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling);
+
+#define OP_vkGetMemoryHostPointerPropertiesEXT 20313
+#endif
+#ifdef VK_AMD_buffer_marker
+#define OP_vkCmdWriteBufferMarkerAMD 20314
+#endif
+#ifdef VK_AMD_shader_core_properties
+void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ VulkanStream* vkStream,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ VulkanStream* vkStream,
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling);
+
+void marshal_VkVertexInputBindingDivisorDescriptionEXT(
+ VulkanStream* vkStream,
+ const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling);
+
+void unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
+ VulkanStream* vkStream,
+ VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling);
+
+void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ VulkanStream* vkStream,
+ VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void marshal_VkQueueFamilyCheckpointPropertiesNV(
+ VulkanStream* vkStream,
+ const VkQueueFamilyCheckpointPropertiesNV* forMarshaling);
+
+void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
+ VulkanStream* vkStream,
+ VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling);
+
+void marshal_VkCheckpointDataNV(
+ VulkanStream* vkStream,
+ const VkCheckpointDataNV* forMarshaling);
+
+void unmarshal_VkCheckpointDataNV(
+ VulkanStream* vkStream,
+ VkCheckpointDataNV* forUnmarshaling);
+
+#define OP_vkCmdSetCheckpointNV 20315
+#define OP_vkGetQueueCheckpointDataNV 20316
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
new file mode 100644
index 0000000..2cfdf63
--- /dev/null
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -0,0 +1,90 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VK_ANDROID_native_buffer 1
+#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER 11
+
+/* NOTE ON VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 6
+ *
+ * This version of the extension transitions from gralloc0 to gralloc1 usage
+ * flags (int -> 2x uint64_t). The WSI implementation will temporarily continue
+ * to fill out deprecated fields in VkNativeBufferANDROID, and will call the
+ * deprecated vkGetSwapchainGrallocUsageANDROID if the new
+ * vkGetSwapchainGrallocUsage2ANDROID is not supported. This transitionary
+ * backwards-compatibility support is temporary, and will likely be removed in
+ * (along with all gralloc0 support) in a future release.
+ */
+#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 7
+#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME "VK_ANDROID_native_buffer"
+
+#define VK_ANDROID_NATIVE_BUFFER_ENUM(type,id) ((type)(1000000000 + (1000 * (VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER - 1)) + (id)))
+#define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0)
+#define VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 1)
+#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 2)
+
+typedef enum VkSwapchainImageUsageFlagBitsANDROID {
+ VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0x00000001,
+ VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSwapchainImageUsageFlagBitsANDROID;
+typedef VkFlags VkSwapchainImageUsageFlagsANDROID;
+
+typedef struct {
+ VkStructureType sType; // must be VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID
+ const void* pNext;
+
+ // Buffer handle and stride returned from gralloc alloc()
+ const uint32_t* handle;
+ int stride;
+
+ // Gralloc format and usage requested when the buffer was allocated.
+ int format;
+ int usage; // DEPRECATED in SPEC_VERSION 6
+ // -- Added in SPEC_VERSION 6 --
+ uint64_t consumer;
+ uint64_t producer;
+} VkNativeBufferANDROID;
+
+typedef struct {
+ VkStructureType sType; // must be VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID
+ const void* pNext;
+
+ VkSwapchainImageUsageFlagsANDROID usage;
+} VkSwapchainImageCreateInfoANDROID;
+
+typedef struct {
+ VkStructureType sType; // must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID
+ const void* pNext;
+
+ VkBool32 sharedImage;
+} VkPhysicalDevicePresentationPropertiesANDROID;
+
+// -- DEPRECATED in SPEC_VERSION 6 --
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
+// -- ADDED in SPEC_VERSION 6 --
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsage2ANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);
+
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
\ No newline at end of file
diff --git a/system/vulkan_enc/vk_platform_compat.h b/system/vulkan_enc/vk_platform_compat.h
new file mode 100644
index 0000000..e182bac
--- /dev/null
+++ b/system/vulkan_enc/vk_platform_compat.h
@@ -0,0 +1,30 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+#if VK_HEADER_VERSION < 76
+
+typedef struct VkBaseOutStructure {
+ VkStructureType sType;
+ struct VkBaseOutStructure* pNext;
+} VkBaseOutStructure;
+
+typedef struct VkBaseInStructure {
+ VkStructureType sType;
+ const struct VkBaseInStructure* pNext;
+} VkBaseInStructure;
+
+#endif // VK_HEADER_VERSION < 76
diff --git a/tests/gles_android_wrapper/Android.mk b/tests/gles_android_wrapper/Android.mk
index d97212d..13e0cfc 100644
--- a/tests/gles_android_wrapper/Android.mk
+++ b/tests/gles_android_wrapper/Android.mk
@@ -3,7 +3,7 @@
#### libGLESv1_CM_emul.so
$(call emugl-begin-shared-library,libGLESv1_CM_emul)
$(call emugl-import,libGLESv1_enc)
-$(call emugl-gen-wrapper,$(EMUGL_PATH)/system/GLESv1_enc,gl)
+$(call emugl-gen-wrapper,$(GOLDFISH_OPENGL_PATH)/system/GLESv1_enc,gl)
$(call emugl-set-shared-library-subpath,egl)
LOCAL_SRC_FILES += glesv1_emul_ifc.cpp
@@ -19,7 +19,7 @@
#### libGLESv2_CM_emul.so
$(call emugl-begin-shared-library, libGLESv2_emul)
$(call emugl-import,libGLESv2_enc)
-$(call emugl-gen-wrapper,$(EMUGL_PATH)/system/GLESv2_enc,gl2)
+$(call emugl-gen-wrapper,$(GOLDFISH_OPENGL_PATH)/system/GLESv2_enc,gl2)
LOCAL_SRC_FILES += glesv2_emul_ifc.cpp
$(call emugl-set-shared-library-subpath,egl)
$(call emugl-end-module)
