blob: 0e28919f01c4ce989e856c1a8f7d004d99b0aad8 [file] [log] [blame]
// *** THIS FILE IS GENERATED - DO NOT EDIT ***
// See helper_file_generator.py for modifications
/***************************************************************************
*
* Copyright (c) 2015-2019 The Khronos Group Inc.
* Copyright (c) 2015-2019 Valve Corporation
* Copyright (c) 2015-2019 LunarG, Inc.
* Copyright (c) 2015-2019 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.
*
* Author: Mark Lobodzinski <mark@lunarg.com>
* Author: Courtney Goeltzenleuchter <courtneygo@google.com>
* Author: Tobin Ehlis <tobine@google.com>
* Author: Chris Forbes <chrisforbes@google.com>
* Author: John Zulauf<jzulauf@lunarg.com>
*
****************************************************************************/
#pragma once
#include <vulkan/vulkan.h>
void *SafePnextCopy(const void *pNext);
void FreePnextChain(const void *pNext);
char *SafeStringCopy(const char *in_string);
struct safe_VkApplicationInfo {
VkStructureType sType;
const void* pNext;
const char* pApplicationName;
uint32_t applicationVersion;
const char* pEngineName;
uint32_t engineVersion;
uint32_t apiVersion;
safe_VkApplicationInfo(const VkApplicationInfo* in_struct);
safe_VkApplicationInfo(const safe_VkApplicationInfo& src);
safe_VkApplicationInfo& operator=(const safe_VkApplicationInfo& src);
safe_VkApplicationInfo();
~safe_VkApplicationInfo();
void initialize(const VkApplicationInfo* in_struct);
void initialize(const safe_VkApplicationInfo* src);
VkApplicationInfo *ptr() { return reinterpret_cast<VkApplicationInfo *>(this); }
VkApplicationInfo const *ptr() const { return reinterpret_cast<VkApplicationInfo const *>(this); }
};
struct safe_VkInstanceCreateInfo {
VkStructureType sType;
const void* pNext;
VkInstanceCreateFlags flags;
safe_VkApplicationInfo* pApplicationInfo;
uint32_t enabledLayerCount;
const char* const* ppEnabledLayerNames;
uint32_t enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct);
safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& src);
safe_VkInstanceCreateInfo& operator=(const safe_VkInstanceCreateInfo& src);
safe_VkInstanceCreateInfo();
~safe_VkInstanceCreateInfo();
void initialize(const VkInstanceCreateInfo* in_struct);
void initialize(const safe_VkInstanceCreateInfo* src);
VkInstanceCreateInfo *ptr() { return reinterpret_cast<VkInstanceCreateInfo *>(this); }
VkInstanceCreateInfo const *ptr() const { return reinterpret_cast<VkInstanceCreateInfo const *>(this); }
};
struct safe_VkAllocationCallbacks {
void* pUserData;
PFN_vkAllocationFunction pfnAllocation;
PFN_vkReallocationFunction pfnReallocation;
PFN_vkFreeFunction pfnFree;
PFN_vkInternalAllocationNotification pfnInternalAllocation;
PFN_vkInternalFreeNotification pfnInternalFree;
safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct);
safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& src);
safe_VkAllocationCallbacks& operator=(const safe_VkAllocationCallbacks& src);
safe_VkAllocationCallbacks();
~safe_VkAllocationCallbacks();
void initialize(const VkAllocationCallbacks* in_struct);
void initialize(const safe_VkAllocationCallbacks* src);
VkAllocationCallbacks *ptr() { return reinterpret_cast<VkAllocationCallbacks *>(this); }
VkAllocationCallbacks const *ptr() const { return reinterpret_cast<VkAllocationCallbacks const *>(this); }
};
struct safe_VkDeviceQueueCreateInfo {
VkStructureType sType;
const void* pNext;
VkDeviceQueueCreateFlags flags;
uint32_t queueFamilyIndex;
uint32_t queueCount;
const float* pQueuePriorities;
safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct);
safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& src);
safe_VkDeviceQueueCreateInfo& operator=(const safe_VkDeviceQueueCreateInfo& src);
safe_VkDeviceQueueCreateInfo();
~safe_VkDeviceQueueCreateInfo();
void initialize(const VkDeviceQueueCreateInfo* in_struct);
void initialize(const safe_VkDeviceQueueCreateInfo* src);
VkDeviceQueueCreateInfo *ptr() { return reinterpret_cast<VkDeviceQueueCreateInfo *>(this); }
VkDeviceQueueCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceQueueCreateInfo const *>(this); }
};
struct safe_VkDeviceCreateInfo {
VkStructureType sType;
const void* pNext;
VkDeviceCreateFlags flags;
uint32_t queueCreateInfoCount;
safe_VkDeviceQueueCreateInfo* pQueueCreateInfos;
uint32_t enabledLayerCount;
const char* const* ppEnabledLayerNames;
uint32_t enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
const VkPhysicalDeviceFeatures* pEnabledFeatures;
safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct);
safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& src);
safe_VkDeviceCreateInfo& operator=(const safe_VkDeviceCreateInfo& src);
safe_VkDeviceCreateInfo();
~safe_VkDeviceCreateInfo();
void initialize(const VkDeviceCreateInfo* in_struct);
void initialize(const safe_VkDeviceCreateInfo* src);
VkDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceCreateInfo *>(this); }
VkDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceCreateInfo const *>(this); }
};
struct safe_VkSubmitInfo {
VkStructureType sType;
const void* pNext;
uint32_t waitSemaphoreCount;
VkSemaphore* pWaitSemaphores;
const VkPipelineStageFlags* pWaitDstStageMask;
uint32_t commandBufferCount;
VkCommandBuffer* pCommandBuffers;
uint32_t signalSemaphoreCount;
VkSemaphore* pSignalSemaphores;
safe_VkSubmitInfo(const VkSubmitInfo* in_struct);
safe_VkSubmitInfo(const safe_VkSubmitInfo& src);
safe_VkSubmitInfo& operator=(const safe_VkSubmitInfo& src);
safe_VkSubmitInfo();
~safe_VkSubmitInfo();
void initialize(const VkSubmitInfo* in_struct);
void initialize(const safe_VkSubmitInfo* src);
VkSubmitInfo *ptr() { return reinterpret_cast<VkSubmitInfo *>(this); }
VkSubmitInfo const *ptr() const { return reinterpret_cast<VkSubmitInfo const *>(this); }
};
struct safe_VkMemoryAllocateInfo {
VkStructureType sType;
const void* pNext;
VkDeviceSize allocationSize;
uint32_t memoryTypeIndex;
safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct);
safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& src);
safe_VkMemoryAllocateInfo& operator=(const safe_VkMemoryAllocateInfo& src);
safe_VkMemoryAllocateInfo();
~safe_VkMemoryAllocateInfo();
void initialize(const VkMemoryAllocateInfo* in_struct);
void initialize(const safe_VkMemoryAllocateInfo* src);
VkMemoryAllocateInfo *ptr() { return reinterpret_cast<VkMemoryAllocateInfo *>(this); }
VkMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const *>(this); }
};
struct safe_VkMappedMemoryRange {
VkStructureType sType;
const void* pNext;
VkDeviceMemory memory;
VkDeviceSize offset;
VkDeviceSize size;
safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct);
safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& src);
safe_VkMappedMemoryRange& operator=(const safe_VkMappedMemoryRange& src);
safe_VkMappedMemoryRange();
~safe_VkMappedMemoryRange();
void initialize(const VkMappedMemoryRange* in_struct);
void initialize(const safe_VkMappedMemoryRange* src);
VkMappedMemoryRange *ptr() { return reinterpret_cast<VkMappedMemoryRange *>(this); }
VkMappedMemoryRange const *ptr() const { return reinterpret_cast<VkMappedMemoryRange const *>(this); }
};
struct safe_VkSparseBufferMemoryBindInfo {
VkBuffer buffer;
uint32_t bindCount;
VkSparseMemoryBind* pBinds;
safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct);
safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& src);
safe_VkSparseBufferMemoryBindInfo& operator=(const safe_VkSparseBufferMemoryBindInfo& src);
safe_VkSparseBufferMemoryBindInfo();
~safe_VkSparseBufferMemoryBindInfo();
void initialize(const VkSparseBufferMemoryBindInfo* in_struct);
void initialize(const safe_VkSparseBufferMemoryBindInfo* src);
VkSparseBufferMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseBufferMemoryBindInfo *>(this); }
VkSparseBufferMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseBufferMemoryBindInfo const *>(this); }
};
struct safe_VkSparseImageOpaqueMemoryBindInfo {
VkImage image;
uint32_t bindCount;
VkSparseMemoryBind* pBinds;
safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct);
safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& src);
safe_VkSparseImageOpaqueMemoryBindInfo& operator=(const safe_VkSparseImageOpaqueMemoryBindInfo& src);
safe_VkSparseImageOpaqueMemoryBindInfo();
~safe_VkSparseImageOpaqueMemoryBindInfo();
void initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct);
void initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* src);
VkSparseImageOpaqueMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>(this); }
VkSparseImageOpaqueMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const *>(this); }
};
struct safe_VkSparseImageMemoryBindInfo {
VkImage image;
uint32_t bindCount;
VkSparseImageMemoryBind* pBinds;
safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct);
safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& src);
safe_VkSparseImageMemoryBindInfo& operator=(const safe_VkSparseImageMemoryBindInfo& src);
safe_VkSparseImageMemoryBindInfo();
~safe_VkSparseImageMemoryBindInfo();
void initialize(const VkSparseImageMemoryBindInfo* in_struct);
void initialize(const safe_VkSparseImageMemoryBindInfo* src);
VkSparseImageMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo *>(this); }
VkSparseImageMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const *>(this); }
};
struct safe_VkBindSparseInfo {
VkStructureType sType;
const void* pNext;
uint32_t waitSemaphoreCount;
VkSemaphore* pWaitSemaphores;
uint32_t bufferBindCount;
safe_VkSparseBufferMemoryBindInfo* pBufferBinds;
uint32_t imageOpaqueBindCount;
safe_VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
uint32_t imageBindCount;
safe_VkSparseImageMemoryBindInfo* pImageBinds;
uint32_t signalSemaphoreCount;
VkSemaphore* pSignalSemaphores;
safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct);
safe_VkBindSparseInfo(const safe_VkBindSparseInfo& src);
safe_VkBindSparseInfo& operator=(const safe_VkBindSparseInfo& src);
safe_VkBindSparseInfo();
~safe_VkBindSparseInfo();
void initialize(const VkBindSparseInfo* in_struct);
void initialize(const safe_VkBindSparseInfo* src);
VkBindSparseInfo *ptr() { return reinterpret_cast<VkBindSparseInfo *>(this); }
VkBindSparseInfo const *ptr() const { return reinterpret_cast<VkBindSparseInfo const *>(this); }
};
struct safe_VkFenceCreateInfo {
VkStructureType sType;
const void* pNext;
VkFenceCreateFlags flags;
safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct);
safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& src);
safe_VkFenceCreateInfo& operator=(const safe_VkFenceCreateInfo& src);
safe_VkFenceCreateInfo();
~safe_VkFenceCreateInfo();
void initialize(const VkFenceCreateInfo* in_struct);
void initialize(const safe_VkFenceCreateInfo* src);
VkFenceCreateInfo *ptr() { return reinterpret_cast<VkFenceCreateInfo *>(this); }
VkFenceCreateInfo const *ptr() const { return reinterpret_cast<VkFenceCreateInfo const *>(this); }
};
struct safe_VkSemaphoreCreateInfo {
VkStructureType sType;
const void* pNext;
VkSemaphoreCreateFlags flags;
safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct);
safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& src);
safe_VkSemaphoreCreateInfo& operator=(const safe_VkSemaphoreCreateInfo& src);
safe_VkSemaphoreCreateInfo();
~safe_VkSemaphoreCreateInfo();
void initialize(const VkSemaphoreCreateInfo* in_struct);
void initialize(const safe_VkSemaphoreCreateInfo* src);
VkSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkSemaphoreCreateInfo *>(this); }
VkSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkSemaphoreCreateInfo const *>(this); }
};
struct safe_VkEventCreateInfo {
VkStructureType sType;
const void* pNext;
VkEventCreateFlags flags;
safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct);
safe_VkEventCreateInfo(const safe_VkEventCreateInfo& src);
safe_VkEventCreateInfo& operator=(const safe_VkEventCreateInfo& src);
safe_VkEventCreateInfo();
~safe_VkEventCreateInfo();
void initialize(const VkEventCreateInfo* in_struct);
void initialize(const safe_VkEventCreateInfo* src);
VkEventCreateInfo *ptr() { return reinterpret_cast<VkEventCreateInfo *>(this); }
VkEventCreateInfo const *ptr() const { return reinterpret_cast<VkEventCreateInfo const *>(this); }
};
struct safe_VkQueryPoolCreateInfo {
VkStructureType sType;
const void* pNext;
VkQueryPoolCreateFlags flags;
VkQueryType queryType;
uint32_t queryCount;
VkQueryPipelineStatisticFlags pipelineStatistics;
safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct);
safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& src);
safe_VkQueryPoolCreateInfo& operator=(const safe_VkQueryPoolCreateInfo& src);
safe_VkQueryPoolCreateInfo();
~safe_VkQueryPoolCreateInfo();
void initialize(const VkQueryPoolCreateInfo* in_struct);
void initialize(const safe_VkQueryPoolCreateInfo* src);
VkQueryPoolCreateInfo *ptr() { return reinterpret_cast<VkQueryPoolCreateInfo *>(this); }
VkQueryPoolCreateInfo const *ptr() const { return reinterpret_cast<VkQueryPoolCreateInfo const *>(this); }
};
struct safe_VkBufferCreateInfo {
VkStructureType sType;
const void* pNext;
VkBufferCreateFlags flags;
VkDeviceSize size;
VkBufferUsageFlags usage;
VkSharingMode sharingMode;
uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices;
safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct);
safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& src);
safe_VkBufferCreateInfo& operator=(const safe_VkBufferCreateInfo& src);
safe_VkBufferCreateInfo();
~safe_VkBufferCreateInfo();
void initialize(const VkBufferCreateInfo* in_struct);
void initialize(const safe_VkBufferCreateInfo* src);
VkBufferCreateInfo *ptr() { return reinterpret_cast<VkBufferCreateInfo *>(this); }
VkBufferCreateInfo const *ptr() const { return reinterpret_cast<VkBufferCreateInfo const *>(this); }
};
struct safe_VkBufferViewCreateInfo {
VkStructureType sType;
const void* pNext;
VkBufferViewCreateFlags flags;
VkBuffer buffer;
VkFormat format;
VkDeviceSize offset;
VkDeviceSize range;
safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct);
safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& src);
safe_VkBufferViewCreateInfo& operator=(const safe_VkBufferViewCreateInfo& src);
safe_VkBufferViewCreateInfo();
~safe_VkBufferViewCreateInfo();
void initialize(const VkBufferViewCreateInfo* in_struct);
void initialize(const safe_VkBufferViewCreateInfo* src);
VkBufferViewCreateInfo *ptr() { return reinterpret_cast<VkBufferViewCreateInfo *>(this); }
VkBufferViewCreateInfo const *ptr() const { return reinterpret_cast<VkBufferViewCreateInfo const *>(this); }
};
struct safe_VkImageCreateInfo {
VkStructureType sType;
const void* pNext;
VkImageCreateFlags flags;
VkImageType imageType;
VkFormat format;
VkExtent3D extent;
uint32_t mipLevels;
uint32_t arrayLayers;
VkSampleCountFlagBits samples;
VkImageTiling tiling;
VkImageUsageFlags usage;
VkSharingMode sharingMode;
uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices;
VkImageLayout initialLayout;
safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct);
safe_VkImageCreateInfo(const safe_VkImageCreateInfo& src);
safe_VkImageCreateInfo& operator=(const safe_VkImageCreateInfo& src);
safe_VkImageCreateInfo();
~safe_VkImageCreateInfo();
void initialize(const VkImageCreateInfo* in_struct);
void initialize(const safe_VkImageCreateInfo* src);
VkImageCreateInfo *ptr() { return reinterpret_cast<VkImageCreateInfo *>(this); }
VkImageCreateInfo const *ptr() const { return reinterpret_cast<VkImageCreateInfo const *>(this); }
};
struct safe_VkImageViewCreateInfo {
VkStructureType sType;
const void* pNext;
VkImageViewCreateFlags flags;
VkImage image;
VkImageViewType viewType;
VkFormat format;
VkComponentMapping components;
VkImageSubresourceRange subresourceRange;
safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct);
safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& src);
safe_VkImageViewCreateInfo& operator=(const safe_VkImageViewCreateInfo& src);
safe_VkImageViewCreateInfo();
~safe_VkImageViewCreateInfo();
void initialize(const VkImageViewCreateInfo* in_struct);
void initialize(const safe_VkImageViewCreateInfo* src);
VkImageViewCreateInfo *ptr() { return reinterpret_cast<VkImageViewCreateInfo *>(this); }
VkImageViewCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewCreateInfo const *>(this); }
};
struct safe_VkShaderModuleCreateInfo {
VkStructureType sType;
const void* pNext;
VkShaderModuleCreateFlags flags;
size_t codeSize;
const uint32_t* pCode;
safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct);
safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& src);
safe_VkShaderModuleCreateInfo& operator=(const safe_VkShaderModuleCreateInfo& src);
safe_VkShaderModuleCreateInfo();
~safe_VkShaderModuleCreateInfo();
void initialize(const VkShaderModuleCreateInfo* in_struct);
void initialize(const safe_VkShaderModuleCreateInfo* src);
VkShaderModuleCreateInfo *ptr() { return reinterpret_cast<VkShaderModuleCreateInfo *>(this); }
VkShaderModuleCreateInfo const *ptr() const { return reinterpret_cast<VkShaderModuleCreateInfo const *>(this); }
};
struct safe_VkPipelineCacheCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineCacheCreateFlags flags;
size_t initialDataSize;
const void* pInitialData;
safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct);
safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& src);
safe_VkPipelineCacheCreateInfo& operator=(const safe_VkPipelineCacheCreateInfo& src);
safe_VkPipelineCacheCreateInfo();
~safe_VkPipelineCacheCreateInfo();
void initialize(const VkPipelineCacheCreateInfo* in_struct);
void initialize(const safe_VkPipelineCacheCreateInfo* src);
VkPipelineCacheCreateInfo *ptr() { return reinterpret_cast<VkPipelineCacheCreateInfo *>(this); }
VkPipelineCacheCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineCacheCreateInfo const *>(this); }
};
struct safe_VkSpecializationInfo {
uint32_t mapEntryCount;
const VkSpecializationMapEntry* pMapEntries;
size_t dataSize;
const void* pData;
safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct);
safe_VkSpecializationInfo(const safe_VkSpecializationInfo& src);
safe_VkSpecializationInfo& operator=(const safe_VkSpecializationInfo& src);
safe_VkSpecializationInfo();
~safe_VkSpecializationInfo();
void initialize(const VkSpecializationInfo* in_struct);
void initialize(const safe_VkSpecializationInfo* src);
VkSpecializationInfo *ptr() { return reinterpret_cast<VkSpecializationInfo *>(this); }
VkSpecializationInfo const *ptr() const { return reinterpret_cast<VkSpecializationInfo const *>(this); }
};
struct safe_VkPipelineShaderStageCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineShaderStageCreateFlags flags;
VkShaderStageFlagBits stage;
VkShaderModule module;
const char* pName;
safe_VkSpecializationInfo* pSpecializationInfo;
safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct);
safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& src);
safe_VkPipelineShaderStageCreateInfo& operator=(const safe_VkPipelineShaderStageCreateInfo& src);
safe_VkPipelineShaderStageCreateInfo();
~safe_VkPipelineShaderStageCreateInfo();
void initialize(const VkPipelineShaderStageCreateInfo* in_struct);
void initialize(const safe_VkPipelineShaderStageCreateInfo* src);
VkPipelineShaderStageCreateInfo *ptr() { return reinterpret_cast<VkPipelineShaderStageCreateInfo *>(this); }
VkPipelineShaderStageCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineShaderStageCreateInfo const *>(this); }
};
struct safe_VkPipelineVertexInputStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineVertexInputStateCreateFlags flags;
uint32_t vertexBindingDescriptionCount;
const VkVertexInputBindingDescription* pVertexBindingDescriptions;
uint32_t vertexAttributeDescriptionCount;
const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct);
safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& src);
safe_VkPipelineVertexInputStateCreateInfo& operator=(const safe_VkPipelineVertexInputStateCreateInfo& src);
safe_VkPipelineVertexInputStateCreateInfo();
~safe_VkPipelineVertexInputStateCreateInfo();
void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineVertexInputStateCreateInfo* src);
VkPipelineVertexInputStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>(this); }
VkPipelineVertexInputStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const *>(this); }
};
struct safe_VkPipelineInputAssemblyStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineInputAssemblyStateCreateFlags flags;
VkPrimitiveTopology topology;
VkBool32 primitiveRestartEnable;
safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct);
safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& src);
safe_VkPipelineInputAssemblyStateCreateInfo& operator=(const safe_VkPipelineInputAssemblyStateCreateInfo& src);
safe_VkPipelineInputAssemblyStateCreateInfo();
~safe_VkPipelineInputAssemblyStateCreateInfo();
void initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* src);
VkPipelineInputAssemblyStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>(this); }
VkPipelineInputAssemblyStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const *>(this); }
};
struct safe_VkPipelineTessellationStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineTessellationStateCreateFlags flags;
uint32_t patchControlPoints;
safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct);
safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& src);
safe_VkPipelineTessellationStateCreateInfo& operator=(const safe_VkPipelineTessellationStateCreateInfo& src);
safe_VkPipelineTessellationStateCreateInfo();
~safe_VkPipelineTessellationStateCreateInfo();
void initialize(const VkPipelineTessellationStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineTessellationStateCreateInfo* src);
VkPipelineTessellationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo *>(this); }
VkPipelineTessellationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationStateCreateInfo const *>(this); }
};
struct safe_VkPipelineViewportStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineViewportStateCreateFlags flags;
uint32_t viewportCount;
const VkViewport* pViewports;
uint32_t scissorCount;
const VkRect2D* pScissors;
safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors);
safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& src);
safe_VkPipelineViewportStateCreateInfo& operator=(const safe_VkPipelineViewportStateCreateInfo& src);
safe_VkPipelineViewportStateCreateInfo();
~safe_VkPipelineViewportStateCreateInfo();
void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors);
void initialize(const safe_VkPipelineViewportStateCreateInfo* src);
VkPipelineViewportStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo *>(this); }
VkPipelineViewportStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineViewportStateCreateInfo const *>(this); }
};
struct safe_VkPipelineRasterizationStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineRasterizationStateCreateFlags flags;
VkBool32 depthClampEnable;
VkBool32 rasterizerDiscardEnable;
VkPolygonMode polygonMode;
VkCullModeFlags cullMode;
VkFrontFace frontFace;
VkBool32 depthBiasEnable;
float depthBiasConstantFactor;
float depthBiasClamp;
float depthBiasSlopeFactor;
float lineWidth;
safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct);
safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& src);
safe_VkPipelineRasterizationStateCreateInfo& operator=(const safe_VkPipelineRasterizationStateCreateInfo& src);
safe_VkPipelineRasterizationStateCreateInfo();
~safe_VkPipelineRasterizationStateCreateInfo();
void initialize(const VkPipelineRasterizationStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineRasterizationStateCreateInfo* src);
VkPipelineRasterizationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>(this); }
VkPipelineRasterizationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const *>(this); }
};
struct safe_VkPipelineMultisampleStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineMultisampleStateCreateFlags flags;
VkSampleCountFlagBits rasterizationSamples;
VkBool32 sampleShadingEnable;
float minSampleShading;
const VkSampleMask* pSampleMask;
VkBool32 alphaToCoverageEnable;
VkBool32 alphaToOneEnable;
safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct);
safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& src);
safe_VkPipelineMultisampleStateCreateInfo& operator=(const safe_VkPipelineMultisampleStateCreateInfo& src);
safe_VkPipelineMultisampleStateCreateInfo();
~safe_VkPipelineMultisampleStateCreateInfo();
void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineMultisampleStateCreateInfo* src);
VkPipelineMultisampleStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>(this); }
VkPipelineMultisampleStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const *>(this); }
};
struct safe_VkPipelineDepthStencilStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineDepthStencilStateCreateFlags flags;
VkBool32 depthTestEnable;
VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp;
VkBool32 depthBoundsTestEnable;
VkBool32 stencilTestEnable;
VkStencilOpState front;
VkStencilOpState back;
float minDepthBounds;
float maxDepthBounds;
safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct);
safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& src);
safe_VkPipelineDepthStencilStateCreateInfo& operator=(const safe_VkPipelineDepthStencilStateCreateInfo& src);
safe_VkPipelineDepthStencilStateCreateInfo();
~safe_VkPipelineDepthStencilStateCreateInfo();
void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* src);
VkPipelineDepthStencilStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>(this); }
VkPipelineDepthStencilStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const *>(this); }
};
struct safe_VkPipelineColorBlendStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineColorBlendStateCreateFlags flags;
VkBool32 logicOpEnable;
VkLogicOp logicOp;
uint32_t attachmentCount;
const VkPipelineColorBlendAttachmentState* pAttachments;
float blendConstants[4];
safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct);
safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& src);
safe_VkPipelineColorBlendStateCreateInfo& operator=(const safe_VkPipelineColorBlendStateCreateInfo& src);
safe_VkPipelineColorBlendStateCreateInfo();
~safe_VkPipelineColorBlendStateCreateInfo();
void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineColorBlendStateCreateInfo* src);
VkPipelineColorBlendStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo *>(this); }
VkPipelineColorBlendStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const *>(this); }
};
struct safe_VkPipelineDynamicStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineDynamicStateCreateFlags flags;
uint32_t dynamicStateCount;
const VkDynamicState* pDynamicStates;
safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct);
safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& src);
safe_VkPipelineDynamicStateCreateInfo& operator=(const safe_VkPipelineDynamicStateCreateInfo& src);
safe_VkPipelineDynamicStateCreateInfo();
~safe_VkPipelineDynamicStateCreateInfo();
void initialize(const VkPipelineDynamicStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineDynamicStateCreateInfo* src);
VkPipelineDynamicStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo *>(this); }
VkPipelineDynamicStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const *>(this); }
};
struct safe_VkGraphicsPipelineCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineCreateFlags flags;
uint32_t stageCount;
safe_VkPipelineShaderStageCreateInfo* pStages;
safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState;
safe_VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
safe_VkPipelineTessellationStateCreateInfo* pTessellationState;
safe_VkPipelineViewportStateCreateInfo* pViewportState;
safe_VkPipelineRasterizationStateCreateInfo* pRasterizationState;
safe_VkPipelineMultisampleStateCreateInfo* pMultisampleState;
safe_VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
safe_VkPipelineColorBlendStateCreateInfo* pColorBlendState;
safe_VkPipelineDynamicStateCreateInfo* pDynamicState;
VkPipelineLayout layout;
VkRenderPass renderPass;
uint32_t subpass;
VkPipeline basePipelineHandle;
int32_t basePipelineIndex;
safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment);
safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& src);
safe_VkGraphicsPipelineCreateInfo& operator=(const safe_VkGraphicsPipelineCreateInfo& src);
safe_VkGraphicsPipelineCreateInfo();
~safe_VkGraphicsPipelineCreateInfo();
void initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment);
void initialize(const safe_VkGraphicsPipelineCreateInfo* src);
VkGraphicsPipelineCreateInfo *ptr() { return reinterpret_cast<VkGraphicsPipelineCreateInfo *>(this); }
VkGraphicsPipelineCreateInfo const *ptr() const { return reinterpret_cast<VkGraphicsPipelineCreateInfo const *>(this); }
};
struct safe_VkComputePipelineCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineCreateFlags flags;
safe_VkPipelineShaderStageCreateInfo stage;
VkPipelineLayout layout;
VkPipeline basePipelineHandle;
int32_t basePipelineIndex;
safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct);
safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& src);
safe_VkComputePipelineCreateInfo& operator=(const safe_VkComputePipelineCreateInfo& src);
safe_VkComputePipelineCreateInfo();
~safe_VkComputePipelineCreateInfo();
void initialize(const VkComputePipelineCreateInfo* in_struct);
void initialize(const safe_VkComputePipelineCreateInfo* src);
VkComputePipelineCreateInfo *ptr() { return reinterpret_cast<VkComputePipelineCreateInfo *>(this); }
VkComputePipelineCreateInfo const *ptr() const { return reinterpret_cast<VkComputePipelineCreateInfo const *>(this); }
};
struct safe_VkPipelineLayoutCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineLayoutCreateFlags flags;
uint32_t setLayoutCount;
VkDescriptorSetLayout* pSetLayouts;
uint32_t pushConstantRangeCount;
const VkPushConstantRange* pPushConstantRanges;
safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct);
safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& src);
safe_VkPipelineLayoutCreateInfo& operator=(const safe_VkPipelineLayoutCreateInfo& src);
safe_VkPipelineLayoutCreateInfo();
~safe_VkPipelineLayoutCreateInfo();
void initialize(const VkPipelineLayoutCreateInfo* in_struct);
void initialize(const safe_VkPipelineLayoutCreateInfo* src);
VkPipelineLayoutCreateInfo *ptr() { return reinterpret_cast<VkPipelineLayoutCreateInfo *>(this); }
VkPipelineLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineLayoutCreateInfo const *>(this); }
};
struct safe_VkSamplerCreateInfo {
VkStructureType sType;
const void* pNext;
VkSamplerCreateFlags flags;
VkFilter magFilter;
VkFilter minFilter;
VkSamplerMipmapMode mipmapMode;
VkSamplerAddressMode addressModeU;
VkSamplerAddressMode addressModeV;
VkSamplerAddressMode addressModeW;
float mipLodBias;
VkBool32 anisotropyEnable;
float maxAnisotropy;
VkBool32 compareEnable;
VkCompareOp compareOp;
float minLod;
float maxLod;
VkBorderColor borderColor;
VkBool32 unnormalizedCoordinates;
safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct);
safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& src);
safe_VkSamplerCreateInfo& operator=(const safe_VkSamplerCreateInfo& src);
safe_VkSamplerCreateInfo();
~safe_VkSamplerCreateInfo();
void initialize(const VkSamplerCreateInfo* in_struct);
void initialize(const safe_VkSamplerCreateInfo* src);
VkSamplerCreateInfo *ptr() { return reinterpret_cast<VkSamplerCreateInfo *>(this); }
VkSamplerCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerCreateInfo const *>(this); }
};
struct safe_VkDescriptorSetLayoutBinding {
uint32_t binding;
VkDescriptorType descriptorType;
uint32_t descriptorCount;
VkShaderStageFlags stageFlags;
VkSampler* pImmutableSamplers;
safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct);
safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& src);
safe_VkDescriptorSetLayoutBinding& operator=(const safe_VkDescriptorSetLayoutBinding& src);
safe_VkDescriptorSetLayoutBinding();
~safe_VkDescriptorSetLayoutBinding();
void initialize(const VkDescriptorSetLayoutBinding* in_struct);
void initialize(const safe_VkDescriptorSetLayoutBinding* src);
VkDescriptorSetLayoutBinding *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBinding *>(this); }
VkDescriptorSetLayoutBinding const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBinding const *>(this); }
};
struct safe_VkDescriptorSetLayoutCreateInfo {
VkStructureType sType;
const void* pNext;
VkDescriptorSetLayoutCreateFlags flags;
uint32_t bindingCount;
safe_VkDescriptorSetLayoutBinding* pBindings;
safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct);
safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& src);
safe_VkDescriptorSetLayoutCreateInfo& operator=(const safe_VkDescriptorSetLayoutCreateInfo& src);
safe_VkDescriptorSetLayoutCreateInfo();
~safe_VkDescriptorSetLayoutCreateInfo();
void initialize(const VkDescriptorSetLayoutCreateInfo* in_struct);
void initialize(const safe_VkDescriptorSetLayoutCreateInfo* src);
VkDescriptorSetLayoutCreateInfo *ptr() { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>(this); }
VkDescriptorSetLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const *>(this); }
};
struct safe_VkDescriptorPoolCreateInfo {
VkStructureType sType;
const void* pNext;
VkDescriptorPoolCreateFlags flags;
uint32_t maxSets;
uint32_t poolSizeCount;
const VkDescriptorPoolSize* pPoolSizes;
safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct);
safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& src);
safe_VkDescriptorPoolCreateInfo& operator=(const safe_VkDescriptorPoolCreateInfo& src);
safe_VkDescriptorPoolCreateInfo();
~safe_VkDescriptorPoolCreateInfo();
void initialize(const VkDescriptorPoolCreateInfo* in_struct);
void initialize(const safe_VkDescriptorPoolCreateInfo* src);
VkDescriptorPoolCreateInfo *ptr() { return reinterpret_cast<VkDescriptorPoolCreateInfo *>(this); }
VkDescriptorPoolCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorPoolCreateInfo const *>(this); }
};
struct safe_VkDescriptorSetAllocateInfo {
VkStructureType sType;
const void* pNext;
VkDescriptorPool descriptorPool;
uint32_t descriptorSetCount;
VkDescriptorSetLayout* pSetLayouts;
safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct);
safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& src);
safe_VkDescriptorSetAllocateInfo& operator=(const safe_VkDescriptorSetAllocateInfo& src);
safe_VkDescriptorSetAllocateInfo();
~safe_VkDescriptorSetAllocateInfo();
void initialize(const VkDescriptorSetAllocateInfo* in_struct);
void initialize(const safe_VkDescriptorSetAllocateInfo* src);
VkDescriptorSetAllocateInfo *ptr() { return reinterpret_cast<VkDescriptorSetAllocateInfo *>(this); }
VkDescriptorSetAllocateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetAllocateInfo const *>(this); }
};
struct safe_VkWriteDescriptorSet {
VkStructureType sType;
const void* pNext;
VkDescriptorSet dstSet;
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
VkDescriptorType descriptorType;
VkDescriptorImageInfo* pImageInfo;
VkDescriptorBufferInfo* pBufferInfo;
VkBufferView* pTexelBufferView;
safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct);
safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& src);
safe_VkWriteDescriptorSet& operator=(const safe_VkWriteDescriptorSet& src);
safe_VkWriteDescriptorSet();
~safe_VkWriteDescriptorSet();
void initialize(const VkWriteDescriptorSet* in_struct);
void initialize(const safe_VkWriteDescriptorSet* src);
VkWriteDescriptorSet *ptr() { return reinterpret_cast<VkWriteDescriptorSet *>(this); }
VkWriteDescriptorSet const *ptr() const { return reinterpret_cast<VkWriteDescriptorSet const *>(this); }
};
struct safe_VkCopyDescriptorSet {
VkStructureType sType;
const void* pNext;
VkDescriptorSet srcSet;
uint32_t srcBinding;
uint32_t srcArrayElement;
VkDescriptorSet dstSet;
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct);
safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& src);
safe_VkCopyDescriptorSet& operator=(const safe_VkCopyDescriptorSet& src);
safe_VkCopyDescriptorSet();
~safe_VkCopyDescriptorSet();
void initialize(const VkCopyDescriptorSet* in_struct);
void initialize(const safe_VkCopyDescriptorSet* src);
VkCopyDescriptorSet *ptr() { return reinterpret_cast<VkCopyDescriptorSet *>(this); }
VkCopyDescriptorSet const *ptr() const { return reinterpret_cast<VkCopyDescriptorSet const *>(this); }
};
struct safe_VkFramebufferCreateInfo {
VkStructureType sType;
const void* pNext;
VkFramebufferCreateFlags flags;
VkRenderPass renderPass;
uint32_t attachmentCount;
VkImageView* pAttachments;
uint32_t width;
uint32_t height;
uint32_t layers;
safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct);
safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& src);
safe_VkFramebufferCreateInfo& operator=(const safe_VkFramebufferCreateInfo& src);
safe_VkFramebufferCreateInfo();
~safe_VkFramebufferCreateInfo();
void initialize(const VkFramebufferCreateInfo* in_struct);
void initialize(const safe_VkFramebufferCreateInfo* src);
VkFramebufferCreateInfo *ptr() { return reinterpret_cast<VkFramebufferCreateInfo *>(this); }
VkFramebufferCreateInfo const *ptr() const { return reinterpret_cast<VkFramebufferCreateInfo const *>(this); }
};
struct safe_VkSubpassDescription {
VkSubpassDescriptionFlags flags;
VkPipelineBindPoint pipelineBindPoint;
uint32_t inputAttachmentCount;
const VkAttachmentReference* pInputAttachments;
uint32_t colorAttachmentCount;
const VkAttachmentReference* pColorAttachments;
const VkAttachmentReference* pResolveAttachments;
const VkAttachmentReference* pDepthStencilAttachment;
uint32_t preserveAttachmentCount;
const uint32_t* pPreserveAttachments;
safe_VkSubpassDescription(const VkSubpassDescription* in_struct);
safe_VkSubpassDescription(const safe_VkSubpassDescription& src);
safe_VkSubpassDescription& operator=(const safe_VkSubpassDescription& src);
safe_VkSubpassDescription();
~safe_VkSubpassDescription();
void initialize(const VkSubpassDescription* in_struct);
void initialize(const safe_VkSubpassDescription* src);
VkSubpassDescription *ptr() { return reinterpret_cast<VkSubpassDescription *>(this); }
VkSubpassDescription const *ptr() const { return reinterpret_cast<VkSubpassDescription const *>(this); }
};
struct safe_VkRenderPassCreateInfo {
VkStructureType sType;
const void* pNext;
VkRenderPassCreateFlags flags;
uint32_t attachmentCount;
const VkAttachmentDescription* pAttachments;
uint32_t subpassCount;
safe_VkSubpassDescription* pSubpasses;
uint32_t dependencyCount;
const VkSubpassDependency* pDependencies;
safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct);
safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& src);
safe_VkRenderPassCreateInfo& operator=(const safe_VkRenderPassCreateInfo& src);
safe_VkRenderPassCreateInfo();
~safe_VkRenderPassCreateInfo();
void initialize(const VkRenderPassCreateInfo* in_struct);
void initialize(const safe_VkRenderPassCreateInfo* src);
VkRenderPassCreateInfo *ptr() { return reinterpret_cast<VkRenderPassCreateInfo *>(this); }
VkRenderPassCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo const *>(this); }
};
struct safe_VkCommandPoolCreateInfo {
VkStructureType sType;
const void* pNext;
VkCommandPoolCreateFlags flags;
uint32_t queueFamilyIndex;
safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct);
safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& src);
safe_VkCommandPoolCreateInfo& operator=(const safe_VkCommandPoolCreateInfo& src);
safe_VkCommandPoolCreateInfo();
~safe_VkCommandPoolCreateInfo();
void initialize(const VkCommandPoolCreateInfo* in_struct);
void initialize(const safe_VkCommandPoolCreateInfo* src);
VkCommandPoolCreateInfo *ptr() { return reinterpret_cast<VkCommandPoolCreateInfo *>(this); }
VkCommandPoolCreateInfo const *ptr() const { return reinterpret_cast<VkCommandPoolCreateInfo const *>(this); }
};
struct safe_VkCommandBufferAllocateInfo {
VkStructureType sType;
const void* pNext;
VkCommandPool commandPool;
VkCommandBufferLevel level;
uint32_t commandBufferCount;
safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct);
safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& src);
safe_VkCommandBufferAllocateInfo& operator=(const safe_VkCommandBufferAllocateInfo& src);
safe_VkCommandBufferAllocateInfo();
~safe_VkCommandBufferAllocateInfo();
void initialize(const VkCommandBufferAllocateInfo* in_struct);
void initialize(const safe_VkCommandBufferAllocateInfo* src);
VkCommandBufferAllocateInfo *ptr() { return reinterpret_cast<VkCommandBufferAllocateInfo *>(this); }
VkCommandBufferAllocateInfo const *ptr() const { return reinterpret_cast<VkCommandBufferAllocateInfo const *>(this); }
};
struct safe_VkCommandBufferInheritanceInfo {
VkStructureType sType;
const void* pNext;
VkRenderPass renderPass;
uint32_t subpass;
VkFramebuffer framebuffer;
VkBool32 occlusionQueryEnable;
VkQueryControlFlags queryFlags;
VkQueryPipelineStatisticFlags pipelineStatistics;
safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct);
safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& src);
safe_VkCommandBufferInheritanceInfo& operator=(const safe_VkCommandBufferInheritanceInfo& src);
safe_VkCommandBufferInheritanceInfo();
~safe_VkCommandBufferInheritanceInfo();
void initialize(const VkCommandBufferInheritanceInfo* in_struct);
void initialize(const safe_VkCommandBufferInheritanceInfo* src);
VkCommandBufferInheritanceInfo *ptr() { return reinterpret_cast<VkCommandBufferInheritanceInfo *>(this); }
VkCommandBufferInheritanceInfo const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceInfo const *>(this); }
};
struct safe_VkCommandBufferBeginInfo {
VkStructureType sType;
const void* pNext;
VkCommandBufferUsageFlags flags;
safe_VkCommandBufferInheritanceInfo* pInheritanceInfo;
safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct);
safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& src);
safe_VkCommandBufferBeginInfo& operator=(const safe_VkCommandBufferBeginInfo& src);
safe_VkCommandBufferBeginInfo();
~safe_VkCommandBufferBeginInfo();
void initialize(const VkCommandBufferBeginInfo* in_struct);
void initialize(const safe_VkCommandBufferBeginInfo* src);
VkCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkCommandBufferBeginInfo *>(this); }
VkCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const *>(this); }
};
struct safe_VkMemoryBarrier {
VkStructureType sType;
const void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct);
safe_VkMemoryBarrier(const safe_VkMemoryBarrier& src);
safe_VkMemoryBarrier& operator=(const safe_VkMemoryBarrier& src);
safe_VkMemoryBarrier();
~safe_VkMemoryBarrier();
void initialize(const VkMemoryBarrier* in_struct);
void initialize(const safe_VkMemoryBarrier* src);
VkMemoryBarrier *ptr() { return reinterpret_cast<VkMemoryBarrier *>(this); }
VkMemoryBarrier const *ptr() const { return reinterpret_cast<VkMemoryBarrier const *>(this); }
};
struct safe_VkBufferMemoryBarrier {
VkStructureType sType;
const void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
uint32_t srcQueueFamilyIndex;
uint32_t dstQueueFamilyIndex;
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize size;
safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct);
safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& src);
safe_VkBufferMemoryBarrier& operator=(const safe_VkBufferMemoryBarrier& src);
safe_VkBufferMemoryBarrier();
~safe_VkBufferMemoryBarrier();
void initialize(const VkBufferMemoryBarrier* in_struct);
void initialize(const safe_VkBufferMemoryBarrier* src);
VkBufferMemoryBarrier *ptr() { return reinterpret_cast<VkBufferMemoryBarrier *>(this); }
VkBufferMemoryBarrier const *ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const *>(this); }
};
struct safe_VkImageMemoryBarrier {
VkStructureType sType;
const void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
VkImageLayout oldLayout;
VkImageLayout newLayout;
uint32_t srcQueueFamilyIndex;
uint32_t dstQueueFamilyIndex;
VkImage image;
VkImageSubresourceRange subresourceRange;
safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct);
safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& src);
safe_VkImageMemoryBarrier& operator=(const safe_VkImageMemoryBarrier& src);
safe_VkImageMemoryBarrier();
~safe_VkImageMemoryBarrier();
void initialize(const VkImageMemoryBarrier* in_struct);
void initialize(const safe_VkImageMemoryBarrier* src);
VkImageMemoryBarrier *ptr() { return reinterpret_cast<VkImageMemoryBarrier *>(this); }
VkImageMemoryBarrier const *ptr() const { return reinterpret_cast<VkImageMemoryBarrier const *>(this); }
};
struct safe_VkRenderPassBeginInfo {
VkStructureType sType;
const void* pNext;
VkRenderPass renderPass;
VkFramebuffer framebuffer;
VkRect2D renderArea;
uint32_t clearValueCount;
const VkClearValue* pClearValues;
safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct);
safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& src);
safe_VkRenderPassBeginInfo& operator=(const safe_VkRenderPassBeginInfo& src);
safe_VkRenderPassBeginInfo();
~safe_VkRenderPassBeginInfo();
void initialize(const VkRenderPassBeginInfo* in_struct);
void initialize(const safe_VkRenderPassBeginInfo* src);
VkRenderPassBeginInfo *ptr() { return reinterpret_cast<VkRenderPassBeginInfo *>(this); }
VkRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const *>(this); }
};
struct safe_VkPhysicalDeviceSubgroupProperties {
VkStructureType sType;
void* pNext;
uint32_t subgroupSize;
VkShaderStageFlags supportedStages;
VkSubgroupFeatureFlags supportedOperations;
VkBool32 quadOperationsInAllStages;
safe_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct);
safe_VkPhysicalDeviceSubgroupProperties(const safe_VkPhysicalDeviceSubgroupProperties& src);
safe_VkPhysicalDeviceSubgroupProperties& operator=(const safe_VkPhysicalDeviceSubgroupProperties& src);
safe_VkPhysicalDeviceSubgroupProperties();
~safe_VkPhysicalDeviceSubgroupProperties();
void initialize(const VkPhysicalDeviceSubgroupProperties* in_struct);
void initialize(const safe_VkPhysicalDeviceSubgroupProperties* src);
VkPhysicalDeviceSubgroupProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties *>(this); }
VkPhysicalDeviceSubgroupProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties const *>(this); }
};
struct safe_VkBindBufferMemoryInfo {
VkStructureType sType;
const void* pNext;
VkBuffer buffer;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct);
safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& src);
safe_VkBindBufferMemoryInfo& operator=(const safe_VkBindBufferMemoryInfo& src);
safe_VkBindBufferMemoryInfo();
~safe_VkBindBufferMemoryInfo();
void initialize(const VkBindBufferMemoryInfo* in_struct);
void initialize(const safe_VkBindBufferMemoryInfo* src);
VkBindBufferMemoryInfo *ptr() { return reinterpret_cast<VkBindBufferMemoryInfo *>(this); }
VkBindBufferMemoryInfo const *ptr() const { return reinterpret_cast<VkBindBufferMemoryInfo const *>(this); }
};
struct safe_VkBindImageMemoryInfo {
VkStructureType sType;
const void* pNext;
VkImage image;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct);
safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& src);
safe_VkBindImageMemoryInfo& operator=(const safe_VkBindImageMemoryInfo& src);
safe_VkBindImageMemoryInfo();
~safe_VkBindImageMemoryInfo();
void initialize(const VkBindImageMemoryInfo* in_struct);
void initialize(const safe_VkBindImageMemoryInfo* src);
VkBindImageMemoryInfo *ptr() { return reinterpret_cast<VkBindImageMemoryInfo *>(this); }
VkBindImageMemoryInfo const *ptr() const { return reinterpret_cast<VkBindImageMemoryInfo const *>(this); }
};
struct safe_VkPhysicalDevice16BitStorageFeatures {
VkStructureType sType;
void* pNext;
VkBool32 storageBuffer16BitAccess;
VkBool32 uniformAndStorageBuffer16BitAccess;
VkBool32 storagePushConstant16;
VkBool32 storageInputOutput16;
safe_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct);
safe_VkPhysicalDevice16BitStorageFeatures(const safe_VkPhysicalDevice16BitStorageFeatures& src);
safe_VkPhysicalDevice16BitStorageFeatures& operator=(const safe_VkPhysicalDevice16BitStorageFeatures& src);
safe_VkPhysicalDevice16BitStorageFeatures();
~safe_VkPhysicalDevice16BitStorageFeatures();
void initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct);
void initialize(const safe_VkPhysicalDevice16BitStorageFeatures* src);
VkPhysicalDevice16BitStorageFeatures *ptr() { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>(this); }
VkPhysicalDevice16BitStorageFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures const *>(this); }
};
struct safe_VkMemoryDedicatedRequirements {
VkStructureType sType;
void* pNext;
VkBool32 prefersDedicatedAllocation;
VkBool32 requiresDedicatedAllocation;
safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct);
safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& src);
safe_VkMemoryDedicatedRequirements& operator=(const safe_VkMemoryDedicatedRequirements& src);
safe_VkMemoryDedicatedRequirements();
~safe_VkMemoryDedicatedRequirements();
void initialize(const VkMemoryDedicatedRequirements* in_struct);
void initialize(const safe_VkMemoryDedicatedRequirements* src);
VkMemoryDedicatedRequirements *ptr() { return reinterpret_cast<VkMemoryDedicatedRequirements *>(this); }
VkMemoryDedicatedRequirements const *ptr() const { return reinterpret_cast<VkMemoryDedicatedRequirements const *>(this); }
};
struct safe_VkMemoryDedicatedAllocateInfo {
VkStructureType sType;
const void* pNext;
VkImage image;
VkBuffer buffer;
safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct);
safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& src);
safe_VkMemoryDedicatedAllocateInfo& operator=(const safe_VkMemoryDedicatedAllocateInfo& src);
safe_VkMemoryDedicatedAllocateInfo();
~safe_VkMemoryDedicatedAllocateInfo();
void initialize(const VkMemoryDedicatedAllocateInfo* in_struct);
void initialize(const safe_VkMemoryDedicatedAllocateInfo* src);
VkMemoryDedicatedAllocateInfo *ptr() { return reinterpret_cast<VkMemoryDedicatedAllocateInfo *>(this); }
VkMemoryDedicatedAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryDedicatedAllocateInfo const *>(this); }
};
struct safe_VkMemoryAllocateFlagsInfo {
VkStructureType sType;
const void* pNext;
VkMemoryAllocateFlags flags;
uint32_t deviceMask;
safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct);
safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& src);
safe_VkMemoryAllocateFlagsInfo& operator=(const safe_VkMemoryAllocateFlagsInfo& src);
safe_VkMemoryAllocateFlagsInfo();
~safe_VkMemoryAllocateFlagsInfo();
void initialize(const VkMemoryAllocateFlagsInfo* in_struct);
void initialize(const safe_VkMemoryAllocateFlagsInfo* src);
VkMemoryAllocateFlagsInfo *ptr() { return reinterpret_cast<VkMemoryAllocateFlagsInfo *>(this); }
VkMemoryAllocateFlagsInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateFlagsInfo const *>(this); }
};
struct safe_VkDeviceGroupRenderPassBeginInfo {
VkStructureType sType;
const void* pNext;
uint32_t deviceMask;
uint32_t deviceRenderAreaCount;
const VkRect2D* pDeviceRenderAreas;
safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct);
safe_VkDeviceGroupRenderPassBeginInfo(const safe_VkDeviceGroupRenderPassBeginInfo& src);
safe_VkDeviceGroupRenderPassBeginInfo& operator=(const safe_VkDeviceGroupRenderPassBeginInfo& src);
safe_VkDeviceGroupRenderPassBeginInfo();
~safe_VkDeviceGroupRenderPassBeginInfo();
void initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct);
void initialize(const safe_VkDeviceGroupRenderPassBeginInfo* src);
VkDeviceGroupRenderPassBeginInfo *ptr() { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo *>(this); }
VkDeviceGroupRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo const *>(this); }
};
struct safe_VkDeviceGroupCommandBufferBeginInfo {
VkStructureType sType;
const void* pNext;
uint32_t deviceMask;
safe_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct);
safe_VkDeviceGroupCommandBufferBeginInfo(const safe_VkDeviceGroupCommandBufferBeginInfo& src);
safe_VkDeviceGroupCommandBufferBeginInfo& operator=(const safe_VkDeviceGroupCommandBufferBeginInfo& src);
safe_VkDeviceGroupCommandBufferBeginInfo();
~safe_VkDeviceGroupCommandBufferBeginInfo();
void initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct);
void initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* src);
VkDeviceGroupCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo *>(this); }
VkDeviceGroupCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo const *>(this); }
};
struct safe_VkDeviceGroupSubmitInfo {
VkStructureType sType;
const void* pNext;
uint32_t waitSemaphoreCount;
const uint32_t* pWaitSemaphoreDeviceIndices;
uint32_t commandBufferCount;
const uint32_t* pCommandBufferDeviceMasks;
uint32_t signalSemaphoreCount;
const uint32_t* pSignalSemaphoreDeviceIndices;
safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct);
safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& src);
safe_VkDeviceGroupSubmitInfo& operator=(const safe_VkDeviceGroupSubmitInfo& src);
safe_VkDeviceGroupSubmitInfo();
~safe_VkDeviceGroupSubmitInfo();
void initialize(const VkDeviceGroupSubmitInfo* in_struct);
void initialize(const safe_VkDeviceGroupSubmitInfo* src);
VkDeviceGroupSubmitInfo *ptr() { return reinterpret_cast<VkDeviceGroupSubmitInfo *>(this); }
VkDeviceGroupSubmitInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupSubmitInfo const *>(this); }
};
struct safe_VkDeviceGroupBindSparseInfo {
VkStructureType sType;
const void* pNext;
uint32_t resourceDeviceIndex;
uint32_t memoryDeviceIndex;
safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct);
safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& src);
safe_VkDeviceGroupBindSparseInfo& operator=(const safe_VkDeviceGroupBindSparseInfo& src);
safe_VkDeviceGroupBindSparseInfo();
~safe_VkDeviceGroupBindSparseInfo();
void initialize(const VkDeviceGroupBindSparseInfo* in_struct);
void initialize(const safe_VkDeviceGroupBindSparseInfo* src);
VkDeviceGroupBindSparseInfo *ptr() { return reinterpret_cast<VkDeviceGroupBindSparseInfo *>(this); }
VkDeviceGroupBindSparseInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupBindSparseInfo const *>(this); }
};
struct safe_VkBindBufferMemoryDeviceGroupInfo {
VkStructureType sType;
const void* pNext;
uint32_t deviceIndexCount;
const uint32_t* pDeviceIndices;
safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct);
safe_VkBindBufferMemoryDeviceGroupInfo(const safe_VkBindBufferMemoryDeviceGroupInfo& src);
safe_VkBindBufferMemoryDeviceGroupInfo& operator=(const safe_VkBindBufferMemoryDeviceGroupInfo& src);
safe_VkBindBufferMemoryDeviceGroupInfo();
~safe_VkBindBufferMemoryDeviceGroupInfo();
void initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct);
void initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* src);
VkBindBufferMemoryDeviceGroupInfo *ptr() { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>(this); }
VkBindBufferMemoryDeviceGroupInfo const *ptr() const { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo const *>(this); }
};
struct safe_VkBindImageMemoryDeviceGroupInfo {
VkStructureType sType;
const void* pNext;
uint32_t deviceIndexCount;
const uint32_t* pDeviceIndices;
uint32_t splitInstanceBindRegionCount;
const VkRect2D* pSplitInstanceBindRegions;
safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct);
safe_VkBindImageMemoryDeviceGroupInfo(const safe_VkBindImageMemoryDeviceGroupInfo& src);
safe_VkBindImageMemoryDeviceGroupInfo& operator=(const safe_VkBindImageMemoryDeviceGroupInfo& src);
safe_VkBindImageMemoryDeviceGroupInfo();
~safe_VkBindImageMemoryDeviceGroupInfo();
void initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct);
void initialize(const safe_VkBindImageMemoryDeviceGroupInfo* src);
VkBindImageMemoryDeviceGroupInfo *ptr() { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>(this); }
VkBindImageMemoryDeviceGroupInfo const *ptr() const { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo const *>(this); }
};
struct safe_VkPhysicalDeviceGroupProperties {
VkStructureType sType;
void* pNext;
uint32_t physicalDeviceCount;
VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
VkBool32 subsetAllocation;
safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct);
safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& src);
safe_VkPhysicalDeviceGroupProperties& operator=(const safe_VkPhysicalDeviceGroupProperties& src);
safe_VkPhysicalDeviceGroupProperties();
~safe_VkPhysicalDeviceGroupProperties();
void initialize(const VkPhysicalDeviceGroupProperties* in_struct);
void initialize(const safe_VkPhysicalDeviceGroupProperties* src);
VkPhysicalDeviceGroupProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceGroupProperties *>(this); }
VkPhysicalDeviceGroupProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceGroupProperties const *>(this); }
};
struct safe_VkDeviceGroupDeviceCreateInfo {
VkStructureType sType;
const void* pNext;
uint32_t physicalDeviceCount;
VkPhysicalDevice* pPhysicalDevices;
safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct);
safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& src);
safe_VkDeviceGroupDeviceCreateInfo& operator=(const safe_VkDeviceGroupDeviceCreateInfo& src);
safe_VkDeviceGroupDeviceCreateInfo();
~safe_VkDeviceGroupDeviceCreateInfo();
void initialize(const VkDeviceGroupDeviceCreateInfo* in_struct);
void initialize(const safe_VkDeviceGroupDeviceCreateInfo* src);
VkDeviceGroupDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo *>(this); }
VkDeviceGroupDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo const *>(this); }
};
struct safe_VkBufferMemoryRequirementsInfo2 {
VkStructureType sType;
const void* pNext;
VkBuffer buffer;
safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct);
safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& src);
safe_VkBufferMemoryRequirementsInfo2& operator=(const safe_VkBufferMemoryRequirementsInfo2& src);
safe_VkBufferMemoryRequirementsInfo2();
~safe_VkBufferMemoryRequirementsInfo2();
void initialize(const VkBufferMemoryRequirementsInfo2* in_struct);
void initialize(const safe_VkBufferMemoryRequirementsInfo2* src);
VkBufferMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>(this); }
VkBufferMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 const *>(this); }
};
struct safe_VkImageMemoryRequirementsInfo2 {
VkStructureType sType;
const void* pNext;
VkImage image;
safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct);
safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& src);
safe_VkImageMemoryRequirementsInfo2& operator=(const safe_VkImageMemoryRequirementsInfo2& src);
safe_VkImageMemoryRequirementsInfo2();
~safe_VkImageMemoryRequirementsInfo2();
void initialize(const VkImageMemoryRequirementsInfo2* in_struct);
void initialize(const safe_VkImageMemoryRequirementsInfo2* src);
VkImageMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkImageMemoryRequirementsInfo2 *>(this); }
VkImageMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkImageMemoryRequirementsInfo2 const *>(this); }
};
struct safe_VkImageSparseMemoryRequirementsInfo2 {
VkStructureType sType;
const void* pNext;
VkImage image;
safe_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct);
safe_VkImageSparseMemoryRequirementsInfo2(const safe_VkImageSparseMemoryRequirementsInfo2& src);
safe_VkImageSparseMemoryRequirementsInfo2& operator=(const safe_VkImageSparseMemoryRequirementsInfo2& src);
safe_VkImageSparseMemoryRequirementsInfo2();
~safe_VkImageSparseMemoryRequirementsInfo2();
void initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct);
void initialize(const safe_VkImageSparseMemoryRequirementsInfo2* src);
VkImageSparseMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 *>(this); }
VkImageSparseMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 const *>(this); }
};
struct safe_VkMemoryRequirements2 {
VkStructureType sType;
void* pNext;
VkMemoryRequirements memoryRequirements;
safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct);
safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& src);
safe_VkMemoryRequirements2& operator=(const safe_VkMemoryRequirements2& src);
safe_VkMemoryRequirements2();
~safe_VkMemoryRequirements2();
void initialize(const VkMemoryRequirements2* in_struct);
void initialize(const safe_VkMemoryRequirements2* src);
VkMemoryRequirements2 *ptr() { return reinterpret_cast<VkMemoryRequirements2 *>(this); }
VkMemoryRequirements2 const *ptr() const { return reinterpret_cast<VkMemoryRequirements2 const *>(this); }
};
struct safe_VkSparseImageMemoryRequirements2 {
VkStructureType sType;
void* pNext;
VkSparseImageMemoryRequirements memoryRequirements;
safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct);
safe_VkSparseImageMemoryRequirements2(const safe_VkSparseImageMemoryRequirements2& src);
safe_VkSparseImageMemoryRequirements2& operator=(const safe_VkSparseImageMemoryRequirements2& src);
safe_VkSparseImageMemoryRequirements2();
~safe_VkSparseImageMemoryRequirements2();
void initialize(const VkSparseImageMemoryRequirements2* in_struct);
void initialize(const safe_VkSparseImageMemoryRequirements2* src);
VkSparseImageMemoryRequirements2 *ptr() { return reinterpret_cast<VkSparseImageMemoryRequirements2 *>(this); }
VkSparseImageMemoryRequirements2 const *ptr() const { return reinterpret_cast<VkSparseImageMemoryRequirements2 const *>(this); }
};
struct safe_VkPhysicalDeviceFeatures2 {
VkStructureType sType;
void* pNext;
VkPhysicalDeviceFeatures features;
safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct);
safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& src);
safe_VkPhysicalDeviceFeatures2& operator=(const safe_VkPhysicalDeviceFeatures2& src);
safe_VkPhysicalDeviceFeatures2();
~safe_VkPhysicalDeviceFeatures2();
void initialize(const VkPhysicalDeviceFeatures2* in_struct);
void initialize(const safe_VkPhysicalDeviceFeatures2* src);
VkPhysicalDeviceFeatures2 *ptr() { return reinterpret_cast<VkPhysicalDeviceFeatures2 *>(this); }
VkPhysicalDeviceFeatures2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFeatures2 const *>(this); }
};
struct safe_VkPhysicalDeviceProperties2 {
VkStructureType sType;
void* pNext;
VkPhysicalDeviceProperties properties;
safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct);
safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& src);
safe_VkPhysicalDeviceProperties2& operator=(const safe_VkPhysicalDeviceProperties2& src);
safe_VkPhysicalDeviceProperties2();
~safe_VkPhysicalDeviceProperties2();
void initialize(const VkPhysicalDeviceProperties2* in_struct);
void initialize(const safe_VkPhysicalDeviceProperties2* src);
VkPhysicalDeviceProperties2 *ptr() { return reinterpret_cast<VkPhysicalDeviceProperties2 *>(this); }
VkPhysicalDeviceProperties2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProperties2 const *>(this); }
};
struct safe_VkFormatProperties2 {
VkStructureType sType;
void* pNext;
VkFormatProperties formatProperties;
safe_VkFormatProperties2(const VkFormatProperties2* in_struct);
safe_VkFormatProperties2(const safe_VkFormatProperties2& src);
safe_VkFormatProperties2& operator=(const safe_VkFormatProperties2& src);
safe_VkFormatProperties2();
~safe_VkFormatProperties2();
void initialize(const VkFormatProperties2* in_struct);
void initialize(const safe_VkFormatProperties2* src);
VkFormatProperties2 *ptr() { return reinterpret_cast<VkFormatProperties2 *>(this); }
VkFormatProperties2 const *ptr() const { return reinterpret_cast<VkFormatProperties2 const *>(this); }
};
struct safe_VkImageFormatProperties2 {
VkStructureType sType;
void* pNext;
VkImageFormatProperties imageFormatProperties;
safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct);
safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& src);
safe_VkImageFormatProperties2& operator=(const safe_VkImageFormatProperties2& src);
safe_VkImageFormatProperties2();
~safe_VkImageFormatProperties2();
void initialize(const VkImageFormatProperties2* in_struct);
void initialize(const safe_VkImageFormatProperties2* src);
VkImageFormatProperties2 *ptr() { return reinterpret_cast<VkImageFormatProperties2 *>(this); }
VkImageFormatProperties2 const *ptr() const { return reinterpret_cast<VkImageFormatProperties2 const *>(this); }
};
struct safe_VkPhysicalDeviceImageFormatInfo2 {
VkStructureType sType;
const void* pNext;
VkFormat format;
VkImageType type;
VkImageTiling tiling;
VkImageUsageFlags usage;
VkImageCreateFlags flags;
safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct);
safe_VkPhysicalDeviceImageFormatInfo2(const safe_VkPhysicalDeviceImageFormatInfo2& src);
safe_VkPhysicalDeviceImageFormatInfo2& operator=(const safe_VkPhysicalDeviceImageFormatInfo2& src);
safe_VkPhysicalDeviceImageFormatInfo2();
~safe_VkPhysicalDeviceImageFormatInfo2();
void initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct);
void initialize(const safe_VkPhysicalDeviceImageFormatInfo2* src);
VkPhysicalDeviceImageFormatInfo2 *ptr() { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 *>(this); }
VkPhysicalDeviceImageFormatInfo2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 const *>(this); }
};
struct safe_VkQueueFamilyProperties2 {
VkStructureType sType;
void* pNext;
VkQueueFamilyProperties queueFamilyProperties;
safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct);
safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& src);
safe_VkQueueFamilyProperties2& operator=(const safe_VkQueueFamilyProperties2& src);
safe_VkQueueFamilyProperties2();
~safe_VkQueueFamilyProperties2();
void initialize(const VkQueueFamilyProperties2* in_struct);
void initialize(const safe_VkQueueFamilyProperties2* src);
VkQueueFamilyProperties2 *ptr() { return reinterpret_cast<VkQueueFamilyProperties2 *>(this); }
VkQueueFamilyProperties2 const *ptr() const { return reinterpret_cast<VkQueueFamilyProperties2 const *>(this); }
};
struct safe_VkPhysicalDeviceMemoryProperties2 {
VkStructureType sType;
void* pNext;
VkPhysicalDeviceMemoryProperties memoryProperties;
safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct);
safe_VkPhysicalDeviceMemoryProperties2(const safe_VkPhysicalDeviceMemoryProperties2& src);
safe_VkPhysicalDeviceMemoryProperties2& operator=(const safe_VkPhysicalDeviceMemoryProperties2& src);
safe_VkPhysicalDeviceMemoryProperties2();
~safe_VkPhysicalDeviceMemoryProperties2();
void initialize(const VkPhysicalDeviceMemoryProperties2* in_struct);
void initialize(const safe_VkPhysicalDeviceMemoryProperties2* src);
VkPhysicalDeviceMemoryProperties2 *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(this); }
VkPhysicalDeviceMemoryProperties2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 const *>(this); }
};
struct safe_VkSparseImageFormatProperties2 {
VkStructureType sType;
void* pNext;
VkSparseImageFormatProperties properties;
safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct);
safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& src);
safe_VkSparseImageFormatProperties2& operator=(const safe_VkSparseImageFormatProperties2& src);
safe_VkSparseImageFormatProperties2();
~safe_VkSparseImageFormatProperties2();
void initialize(const VkSparseImageFormatProperties2* in_struct);
void initialize(const safe_VkSparseImageFormatProperties2* src);
VkSparseImageFormatProperties2 *ptr() { return reinterpret_cast<VkSparseImageFormatProperties2 *>(this); }
VkSparseImageFormatProperties2 const *ptr() const { return reinterpret_cast<VkSparseImageFormatProperties2 const *>(this); }
};
struct safe_VkPhysicalDeviceSparseImageFormatInfo2 {
VkStructureType sType;
const void* pNext;
VkFormat format;
VkImageType type;
VkSampleCountFlagBits samples;
VkImageUsageFlags usage;
VkImageTiling tiling;
safe_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct);
safe_VkPhysicalDeviceSparseImageFormatInfo2(const safe_VkPhysicalDeviceSparseImageFormatInfo2& src);
safe_VkPhysicalDeviceSparseImageFormatInfo2& operator=(const safe_VkPhysicalDeviceSparseImageFormatInfo2& src);
safe_VkPhysicalDeviceSparseImageFormatInfo2();
~safe_VkPhysicalDeviceSparseImageFormatInfo2();
void initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct);
void initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* src);
VkPhysicalDeviceSparseImageFormatInfo2 *ptr() { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 *>(this); }
VkPhysicalDeviceSparseImageFormatInfo2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 const *>(this); }
};
struct safe_VkPhysicalDevicePointClippingProperties {
VkStructureType sType;
void* pNext;
VkPointClippingBehavior pointClippingBehavior;
safe_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct);
safe_VkPhysicalDevicePointClippingProperties(const safe_VkPhysicalDevicePointClippingProperties& src);
safe_VkPhysicalDevicePointClippingProperties& operator=(const safe_VkPhysicalDevicePointClippingProperties& src);
safe_VkPhysicalDevicePointClippingProperties();
~safe_VkPhysicalDevicePointClippingProperties();
void initialize(const VkPhysicalDevicePointClippingProperties* in_struct);
void initialize(const safe_VkPhysicalDevicePointClippingProperties* src);
VkPhysicalDevicePointClippingProperties *ptr() { return reinterpret_cast<VkPhysicalDevicePointClippingProperties *>(this); }
VkPhysicalDevicePointClippingProperties const *ptr() const { return reinterpret_cast<VkPhysicalDevicePointClippingProperties const *>(this); }
};
struct safe_VkRenderPassInputAttachmentAspectCreateInfo {
VkStructureType sType;
const void* pNext;
uint32_t aspectReferenceCount;
const VkInputAttachmentAspectReference* pAspectReferences;
safe_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct);
safe_VkRenderPassInputAttachmentAspectCreateInfo(const safe_VkRenderPassInputAttachmentAspectCreateInfo& src);
safe_VkRenderPassInputAttachmentAspectCreateInfo& operator=(const safe_VkRenderPassInputAttachmentAspectCreateInfo& src);
safe_VkRenderPassInputAttachmentAspectCreateInfo();
~safe_VkRenderPassInputAttachmentAspectCreateInfo();
void initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct);
void initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* src);
VkRenderPassInputAttachmentAspectCreateInfo *ptr() { return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo *>(this); }
VkRenderPassInputAttachmentAspectCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo const *>(this); }
};
struct safe_VkImageViewUsageCreateInfo {
VkStructureType sType;
const void* pNext;
VkImageUsageFlags usage;
safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct);
safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& src);
safe_VkImageViewUsageCreateInfo& operator=(const safe_VkImageViewUsageCreateInfo& src);
safe_VkImageViewUsageCreateInfo();
~safe_VkImageViewUsageCreateInfo();
void initialize(const VkImageViewUsageCreateInfo* in_struct);
void initialize(const safe_VkImageViewUsageCreateInfo* src);
VkImageViewUsageCreateInfo *ptr() { return reinterpret_cast<VkImageViewUsageCreateInfo *>(this); }
VkImageViewUsageCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewUsageCreateInfo const *>(this); }
};
struct safe_VkPipelineTessellationDomainOriginStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkTessellationDomainOrigin domainOrigin;
safe_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct);
safe_VkPipelineTessellationDomainOriginStateCreateInfo(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& src);
safe_VkPipelineTessellationDomainOriginStateCreateInfo& operator=(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& src);
safe_VkPipelineTessellationDomainOriginStateCreateInfo();
~safe_VkPipelineTessellationDomainOriginStateCreateInfo();
void initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct);
void initialize(const safe_VkPipelineTessellationDomainOriginStateCreateInfo* src);
VkPipelineTessellationDomainOriginStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo *>(this); }
VkPipelineTessellationDomainOriginStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo const *>(this); }
};
struct safe_VkRenderPassMultiviewCreateInfo {
VkStructureType sType;
const void* pNext;
uint32_t subpassCount;
const uint32_t* pViewMasks;
uint32_t dependencyCount;
const int32_t* pViewOffsets;
uint32_t correlationMaskCount;
const uint32_t* pCorrelationMasks;
safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct);
safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& src);
safe_VkRenderPassMultiviewCreateInfo& operator=(const safe_VkRenderPassMultiviewCreateInfo& src);
safe_VkRenderPassMultiviewCreateInfo();
~safe_VkRenderPassMultiviewCreateInfo();
void initialize(const VkRenderPassMultiviewCreateInfo* in_struct);
void initialize(const safe_VkRenderPassMultiviewCreateInfo* src);
VkRenderPassMultiviewCreateInfo *ptr() { return reinterpret_cast<VkRenderPassMultiviewCreateInfo *>(this); }
VkRenderPassMultiviewCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassMultiviewCreateInfo const *>(this); }
};
struct safe_VkPhysicalDeviceMultiviewFeatures {
VkStructureType sType;
void* pNext;
VkBool32 multiview;
VkBool32 multiviewGeometryShader;
VkBool32 multiviewTessellationShader;
safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct);
safe_VkPhysicalDeviceMultiviewFeatures(const safe_VkPhysicalDeviceMultiviewFeatures& src);
safe_VkPhysicalDeviceMultiviewFeatures& operator=(const safe_VkPhysicalDeviceMultiviewFeatures& src);
safe_VkPhysicalDeviceMultiviewFeatures();
~safe_VkPhysicalDeviceMultiviewFeatures();
void initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct);
void initialize(const safe_VkPhysicalDeviceMultiviewFeatures* src);
VkPhysicalDeviceMultiviewFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>(this); }
VkPhysicalDeviceMultiviewFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures const *>(this); }
};
struct safe_VkPhysicalDeviceMultiviewProperties {
VkStructureType sType;
void* pNext;
uint32_t maxMultiviewViewCount;
uint32_t maxMultiviewInstanceIndex;
safe_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct);
safe_VkPhysicalDeviceMultiviewProperties(const safe_VkPhysicalDeviceMultiviewProperties& src);
safe_VkPhysicalDeviceMultiviewProperties& operator=(const safe_VkPhysicalDeviceMultiviewProperties& src);
safe_VkPhysicalDeviceMultiviewProperties();
~safe_VkPhysicalDeviceMultiviewProperties();
void initialize(const VkPhysicalDeviceMultiviewProperties* in_struct);
void initialize(const safe_VkPhysicalDeviceMultiviewProperties* src);
VkPhysicalDeviceMultiviewProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties *>(this); }
VkPhysicalDeviceMultiviewProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties const *>(this); }
};
struct safe_VkPhysicalDeviceVariablePointersFeatures {
VkStructureType sType;
void* pNext;
VkBool32 variablePointersStorageBuffer;
VkBool32 variablePointers;
safe_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct);
safe_VkPhysicalDeviceVariablePointersFeatures(const safe_VkPhysicalDeviceVariablePointersFeatures& src);
safe_VkPhysicalDeviceVariablePointersFeatures& operator=(const safe_VkPhysicalDeviceVariablePointersFeatures& src);
safe_VkPhysicalDeviceVariablePointersFeatures();
~safe_VkPhysicalDeviceVariablePointersFeatures();
void initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct);
void initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* src);
VkPhysicalDeviceVariablePointersFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>(this); }
VkPhysicalDeviceVariablePointersFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures const *>(this); }
};
struct safe_VkPhysicalDeviceProtectedMemoryFeatures {
VkStructureType sType;
void* pNext;
VkBool32 protectedMemory;
safe_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct);
safe_VkPhysicalDeviceProtectedMemoryFeatures(const safe_VkPhysicalDeviceProtectedMemoryFeatures& src);
safe_VkPhysicalDeviceProtectedMemoryFeatures& operator=(const safe_VkPhysicalDeviceProtectedMemoryFeatures& src);
safe_VkPhysicalDeviceProtectedMemoryFeatures();
~safe_VkPhysicalDeviceProtectedMemoryFeatures();
void initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct);
void initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* src);
VkPhysicalDeviceProtectedMemoryFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>(this); }
VkPhysicalDeviceProtectedMemoryFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures const *>(this); }
};
struct safe_VkPhysicalDeviceProtectedMemoryProperties {
VkStructureType sType;
void* pNext;
VkBool32 protectedNoFault;
safe_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct);
safe_VkPhysicalDeviceProtectedMemoryProperties(const safe_VkPhysicalDeviceProtectedMemoryProperties& src);
safe_VkPhysicalDeviceProtectedMemoryProperties& operator=(const safe_VkPhysicalDeviceProtectedMemoryProperties& src);
safe_VkPhysicalDeviceProtectedMemoryProperties();
~safe_VkPhysicalDeviceProtectedMemoryProperties();
void initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct);
void initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* src);
VkPhysicalDeviceProtectedMemoryProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties *>(this); }
VkPhysicalDeviceProtectedMemoryProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties const *>(this); }
};
struct safe_VkDeviceQueueInfo2 {
VkStructureType sType;
const void* pNext;
VkDeviceQueueCreateFlags flags;
uint32_t queueFamilyIndex;
uint32_t queueIndex;
safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct);
safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& src);
safe_VkDeviceQueueInfo2& operator=(const safe_VkDeviceQueueInfo2& src);
safe_VkDeviceQueueInfo2();
~safe_VkDeviceQueueInfo2();
void initialize(const VkDeviceQueueInfo2* in_struct);
void initialize(const safe_VkDeviceQueueInfo2* src);
VkDeviceQueueInfo2 *ptr() { return reinterpret_cast<VkDeviceQueueInfo2 *>(this); }
VkDeviceQueueInfo2 const *ptr() const { return reinterpret_cast<VkDeviceQueueInfo2 const *>(this); }
};
struct safe_VkProtectedSubmitInfo {
VkStructureType sType;
const void* pNext;
VkBool32 protectedSubmit;
safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct);
safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& src);
safe_VkProtectedSubmitInfo& operator=(const safe_VkProtectedSubmitInfo& src);
safe_VkProtectedSubmitInfo();
~safe_VkProtectedSubmitInfo();
void initialize(const VkProtectedSubmitInfo* in_struct);
void initialize(const safe_VkProtectedSubmitInfo* src);
VkProtectedSubmitInfo *ptr() { return reinterpret_cast<VkProtectedSubmitInfo *>(this); }
VkProtectedSubmitInfo const *ptr() const { return reinterpret_cast<VkProtectedSubmitInfo const *>(this); }
};
struct safe_VkSamplerYcbcrConversionCreateInfo {
VkStructureType sType;
const void* pNext;
VkFormat format;
VkSamplerYcbcrModelConversion ycbcrModel;
VkSamplerYcbcrRange ycbcrRange;
VkComponentMapping components;
VkChromaLocation xChromaOffset;
VkChromaLocation yChromaOffset;
VkFilter chromaFilter;
VkBool32 forceExplicitReconstruction;
safe_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct);
safe_VkSamplerYcbcrConversionCreateInfo(const safe_VkSamplerYcbcrConversionCreateInfo& src);
safe_VkSamplerYcbcrConversionCreateInfo& operator=(const safe_VkSamplerYcbcrConversionCreateInfo& src);
safe_VkSamplerYcbcrConversionCreateInfo();
~safe_VkSamplerYcbcrConversionCreateInfo();
void initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct);
void initialize(const safe_VkSamplerYcbcrConversionCreateInfo* src);
VkSamplerYcbcrConversionCreateInfo *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo *>(this); }
VkSamplerYcbcrConversionCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo const *>(this); }
};
struct safe_VkSamplerYcbcrConversionInfo {
VkStructureType sType;
const void* pNext;
VkSamplerYcbcrConversion conversion;
safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct);
safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& src);
safe_VkSamplerYcbcrConversionInfo& operator=(const safe_VkSamplerYcbcrConversionInfo& src);
safe_VkSamplerYcbcrConversionInfo();
~safe_VkSamplerYcbcrConversionInfo();
void initialize(const VkSamplerYcbcrConversionInfo* in_struct);
void initialize(const safe_VkSamplerYcbcrConversionInfo* src);
VkSamplerYcbcrConversionInfo *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionInfo *>(this); }
VkSamplerYcbcrConversionInfo const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionInfo const *>(this); }
};
struct safe_VkBindImagePlaneMemoryInfo {
VkStructureType sType;
const void* pNext;
VkImageAspectFlagBits planeAspect;
safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct);
safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& src);
safe_VkBindImagePlaneMemoryInfo& operator=(const safe_VkBindImagePlaneMemoryInfo& src);
safe_VkBindImagePlaneMemoryInfo();
~safe_VkBindImagePlaneMemoryInfo();
void initialize(const VkBindImagePlaneMemoryInfo* in_struct);
void initialize(const safe_VkBindImagePlaneMemoryInfo* src);
VkBindImagePlaneMemoryInfo *ptr() { return reinterpret_cast<VkBindImagePlaneMemoryInfo *>(this); }
VkBindImagePlaneMemoryInfo const *ptr() const { return reinterpret_cast<VkBindImagePlaneMemoryInfo const *>(this); }
};
struct safe_VkImagePlaneMemoryRequirementsInfo {
VkStructureType sType;
const void* pNext;
VkImageAspectFlagBits planeAspect;
safe_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct);
safe_VkImagePlaneMemoryRequirementsInfo(const safe_VkImagePlaneMemoryRequirementsInfo& src);
safe_VkImagePlaneMemoryRequirementsInfo& operator=(const safe_VkImagePlaneMemoryRequirementsInfo& src);
safe_VkImagePlaneMemoryRequirementsInfo();
~safe_VkImagePlaneMemoryRequirementsInfo();
void initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct);
void initialize(const safe_VkImagePlaneMemoryRequirementsInfo* src);
VkImagePlaneMemoryRequirementsInfo *ptr() { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo *>(this); }
VkImagePlaneMemoryRequirementsInfo const *ptr() const { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo const *>(this); }
};
struct safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures {
VkStructureType sType;
void* pNext;
VkBool32 samplerYcbcrConversion;
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct);
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& src);
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& operator=(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& src);
safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures();
~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures();
void initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct);
void initialize(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* src);
VkPhysicalDeviceSamplerYcbcrConversionFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(this); }
VkPhysicalDeviceSamplerYcbcrConversionFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures const *>(this); }
};
struct safe_VkSamplerYcbcrConversionImageFormatProperties {
VkStructureType sType;
void* pNext;
uint32_t combinedImageSamplerDescriptorCount;
safe_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct);
safe_VkSamplerYcbcrConversionImageFormatProperties(const safe_VkSamplerYcbcrConversionImageFormatProperties& src);
safe_VkSamplerYcbcrConversionImageFormatProperties& operator=(const safe_VkSamplerYcbcrConversionImageFormatProperties& src);
safe_VkSamplerYcbcrConversionImageFormatProperties();
~safe_VkSamplerYcbcrConversionImageFormatProperties();
void initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct);
void initialize(const safe_VkSamplerYcbcrConversionImageFormatProperties* src);
VkSamplerYcbcrConversionImageFormatProperties *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties *>(this); }
VkSamplerYcbcrConversionImageFormatProperties const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties const *>(this); }
};
struct safe_VkDescriptorUpdateTemplateCreateInfo {
VkStructureType sType;
const void* pNext;
VkDescriptorUpdateTemplateCreateFlags flags;
uint32_t descriptorUpdateEntryCount;
const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
VkDescriptorUpdateTemplateType templateType;
VkDescriptorSetLayout descriptorSetLayout;
VkPipelineBindPoint pipelineBindPoint;
VkPipelineLayout pipelineLayout;
uint32_t set;
safe_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct);
safe_VkDescriptorUpdateTemplateCreateInfo(const safe_VkDescriptorUpdateTemplateCreateInfo& src);
safe_VkDescriptorUpdateTemplateCreateInfo& operator=(const safe_VkDescriptorUpdateTemplateCreateInfo& src);
safe_VkDescriptorUpdateTemplateCreateInfo();
~safe_VkDescriptorUpdateTemplateCreateInfo();
void initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct);
void initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* src);
VkDescriptorUpdateTemplateCreateInfo *ptr() { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>(this); }
VkDescriptorUpdateTemplateCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo const *>(this); }
};
struct safe_VkPhysicalDeviceExternalImageFormatInfo {
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlagBits handleType;
safe_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct);
safe_VkPhysicalDeviceExternalImageFormatInfo(const safe_VkPhysicalDeviceExternalImageFormatInfo& src);
safe_VkPhysicalDeviceExternalImageFormatInfo& operator=(const safe_VkPhysicalDeviceExternalImageFormatInfo& src);
safe_VkPhysicalDeviceExternalImageFormatInfo();
~safe_VkPhysicalDeviceExternalImageFormatInfo();
void initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct);
void initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* src);
VkPhysicalDeviceExternalImageFormatInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo *>(this); }
VkPhysicalDeviceExternalImageFormatInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo const *>(this); }
};
struct safe_VkExternalImageFormatProperties {
VkStructureType sType;
void* pNext;
VkExternalMemoryProperties externalMemoryProperties;
safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct);
safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& src);
safe_VkExternalImageFormatProperties& operator=(const safe_VkExternalImageFormatProperties& src);
safe_VkExternalImageFormatProperties();
~safe_VkExternalImageFormatProperties();
void initialize(const VkExternalImageFormatProperties* in_struct);
void initialize(const safe_VkExternalImageFormatProperties* src);
VkExternalImageFormatProperties *ptr() { return reinterpret_cast<VkExternalImageFormatProperties *>(this); }
VkExternalImageFormatProperties const *ptr() const { return reinterpret_cast<VkExternalImageFormatProperties const *>(this); }
};
struct safe_VkPhysicalDeviceExternalBufferInfo {
VkStructureType sType;
const void* pNext;
VkBufferCreateFlags flags;
VkBufferUsageFlags usage;
VkExternalMemoryHandleTypeFlagBits handleType;
safe_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct);
safe_VkPhysicalDeviceExternalBufferInfo(const safe_VkPhysicalDeviceExternalBufferInfo& src);
safe_VkPhysicalDeviceExternalBufferInfo& operator=(const safe_VkPhysicalDeviceExternalBufferInfo& src);
safe_VkPhysicalDeviceExternalBufferInfo();
~safe_VkPhysicalDeviceExternalBufferInfo();
void initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct);
void initialize(const safe_VkPhysicalDeviceExternalBufferInfo* src);
VkPhysicalDeviceExternalBufferInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo *>(this); }
VkPhysicalDeviceExternalBufferInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo const *>(this); }
};
struct safe_VkExternalBufferProperties {
VkStructureType sType;
void* pNext;
VkExternalMemoryProperties externalMemoryProperties;
safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct);
safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& src);
safe_VkExternalBufferProperties& operator=(const safe_VkExternalBufferProperties& src);
safe_VkExternalBufferProperties();
~safe_VkExternalBufferProperties();
void initialize(const VkExternalBufferProperties* in_struct);
void initialize(const safe_VkExternalBufferProperties* src);
VkExternalBufferProperties *ptr() { return reinterpret_cast<VkExternalBufferProperties *>(this); }
VkExternalBufferProperties const *ptr() const { return reinterpret_cast<VkExternalBufferProperties const *>(this); }
};
struct safe_VkPhysicalDeviceIDProperties {
VkStructureType sType;
void* pNext;
uint8_t deviceUUID[VK_UUID_SIZE];
uint8_t driverUUID[VK_UUID_SIZE];
uint8_t deviceLUID[VK_LUID_SIZE];
uint32_t deviceNodeMask;
VkBool32 deviceLUIDValid;
safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct);
safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& src);
safe_VkPhysicalDeviceIDProperties& operator=(const safe_VkPhysicalDeviceIDProperties& src);
safe_VkPhysicalDeviceIDProperties();
~safe_VkPhysicalDeviceIDProperties();
void initialize(const VkPhysicalDeviceIDProperties* in_struct);
void initialize(const safe_VkPhysicalDeviceIDProperties* src);
VkPhysicalDeviceIDProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceIDProperties *>(this); }
VkPhysicalDeviceIDProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceIDProperties const *>(this); }
};
struct safe_VkExternalMemoryImageCreateInfo {
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes;
safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct);
safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& src);
safe_VkExternalMemoryImageCreateInfo& operator=(const safe_VkExternalMemoryImageCreateInfo& src);
safe_VkExternalMemoryImageCreateInfo();
~safe_VkExternalMemoryImageCreateInfo();
void initialize(const VkExternalMemoryImageCreateInfo* in_struct);
void initialize(const safe_VkExternalMemoryImageCreateInfo* src);
VkExternalMemoryImageCreateInfo *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfo *>(this); }
VkExternalMemoryImageCreateInfo const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfo const *>(this); }
};
struct safe_VkExternalMemoryBufferCreateInfo {
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes;
safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct);
safe_VkExternalMemoryBufferCreateInfo(const safe_VkExternalMemoryBufferCreateInfo& src);
safe_VkExternalMemoryBufferCreateInfo& operator=(const safe_VkExternalMemoryBufferCreateInfo& src);
safe_VkExternalMemoryBufferCreateInfo();
~safe_VkExternalMemoryBufferCreateInfo();
void initialize(const VkExternalMemoryBufferCreateInfo* in_struct);
void initialize(const safe_VkExternalMemoryBufferCreateInfo* src);
VkExternalMemoryBufferCreateInfo *ptr() { return reinterpret_cast<VkExternalMemoryBufferCreateInfo *>(this); }
VkExternalMemoryBufferCreateInfo const *ptr() const { return reinterpret_cast<VkExternalMemoryBufferCreateInfo const *>(this); }
};
struct safe_VkExportMemoryAllocateInfo {
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes;
safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct);
safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& src);
safe_VkExportMemoryAllocateInfo& operator=(const safe_VkExportMemoryAllocateInfo& src);
safe_VkExportMemoryAllocateInfo();
~safe_VkExportMemoryAllocateInfo();
void initialize(const VkExportMemoryAllocateInfo* in_struct);
void initialize(const safe_VkExportMemoryAllocateInfo* src);
VkExportMemoryAllocateInfo *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfo *>(this); }
VkExportMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfo const *>(this); }
};
struct safe_VkPhysicalDeviceExternalFenceInfo {
VkStructureType sType;
const void* pNext;
VkExternalFenceHandleTypeFlagBits handleType;
safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct);
safe_VkPhysicalDeviceExternalFenceInfo(const safe_VkPhysicalDeviceExternalFenceInfo& src);
safe_VkPhysicalDeviceExternalFenceInfo& operator=(const safe_VkPhysicalDeviceExternalFenceInfo& src);
safe_VkPhysicalDeviceExternalFenceInfo();
~safe_VkPhysicalDeviceExternalFenceInfo();
void initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct);
void initialize(const safe_VkPhysicalDeviceExternalFenceInfo* src);
VkPhysicalDeviceExternalFenceInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo *>(this); }
VkPhysicalDeviceExternalFenceInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo const *>(this); }
};
struct safe_VkExternalFenceProperties {
VkStructureType sType;
void* pNext;
VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
VkExternalFenceHandleTypeFlags compatibleHandleTypes;
VkExternalFenceFeatureFlags externalFenceFeatures;
safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct);
safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& src);
safe_VkExternalFenceProperties& operator=(const safe_VkExternalFenceProperties& src);
safe_VkExternalFenceProperties();
~safe_VkExternalFenceProperties();
void initialize(const VkExternalFenceProperties* in_struct);
void initialize(const safe_VkExternalFenceProperties* src);
VkExternalFenceProperties *ptr() { return reinterpret_cast<VkExternalFenceProperties *>(this); }
VkExternalFenceProperties const *ptr() const { return reinterpret_cast<VkExternalFenceProperties const *>(this); }
};
struct safe_VkExportFenceCreateInfo {
VkStructureType sType;
const void* pNext;
VkExternalFenceHandleTypeFlags handleTypes;
safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct);
safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& src);
safe_VkExportFenceCreateInfo& operator=(const safe_VkExportFenceCreateInfo& src);
safe_VkExportFenceCreateInfo();
~safe_VkExportFenceCreateInfo();
void initialize(const VkExportFenceCreateInfo* in_struct);
void initialize(const safe_VkExportFenceCreateInfo* src);
VkExportFenceCreateInfo *ptr() { return reinterpret_cast<VkExportFenceCreateInfo *>(this); }
VkExportFenceCreateInfo const *ptr() const { return reinterpret_cast<VkExportFenceCreateInfo const *>(this); }
};
struct safe_VkExportSemaphoreCreateInfo {
VkStructureType sType;
const void* pNext;
VkExternalSemaphoreHandleTypeFlags handleTypes;
safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct);
safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& src);
safe_VkExportSemaphoreCreateInfo& operator=(const safe_VkExportSemaphoreCreateInfo& src);
safe_VkExportSemaphoreCreateInfo();
~safe_VkExportSemaphoreCreateInfo();
void initialize(const VkExportSemaphoreCreateInfo* in_struct);
void initialize(const safe_VkExportSemaphoreCreateInfo* src);
VkExportSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkExportSemaphoreCreateInfo *>(this); }
VkExportSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkExportSemaphoreCreateInfo const *>(this); }
};
struct safe_VkPhysicalDeviceExternalSemaphoreInfo {
VkStructureType sType;
const void* pNext;
VkExternalSemaphoreHandleTypeFlagBits handleType;
safe_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct);
safe_VkPhysicalDeviceExternalSemaphoreInfo(const safe_VkPhysicalDeviceExternalSemaphoreInfo& src);
safe_VkPhysicalDeviceExternalSemaphoreInfo& operator=(const safe_VkPhysicalDeviceExternalSemaphoreInfo& src);
safe_VkPhysicalDeviceExternalSemaphoreInfo();
~safe_VkPhysicalDeviceExternalSemaphoreInfo();
void initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct);
void initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* src);
VkPhysicalDeviceExternalSemaphoreInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo *>(this); }
VkPhysicalDeviceExternalSemaphoreInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo const *>(this); }
};
struct safe_VkExternalSemaphoreProperties {
VkStructureType sType;
void* pNext;
VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct);
safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& src);
safe_VkExternalSemaphoreProperties& operator=(const safe_VkExternalSemaphoreProperties& src);
safe_VkExternalSemaphoreProperties();
~safe_VkExternalSemaphoreProperties();
void initialize(const VkExternalSemaphoreProperties* in_struct);
void initialize(const safe_VkExternalSemaphoreProperties* src);
VkExternalSemaphoreProperties *ptr() { return reinterpret_cast<VkExternalSemaphoreProperties *>(this); }
VkExternalSemaphoreProperties const *ptr() const { return reinterpret_cast<VkExternalSemaphoreProperties const *>(this); }
};
struct safe_VkPhysicalDeviceMaintenance3Properties {
VkStructureType sType;
void* pNext;
uint32_t maxPerSetDescriptors;
VkDeviceSize maxMemoryAllocationSize;
safe_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct);
safe_VkPhysicalDeviceMaintenance3Properties(const safe_VkPhysicalDeviceMaintenance3Properties& src);
safe_VkPhysicalDeviceMaintenance3Properties& operator=(const safe_VkPhysicalDeviceMaintenance3Properties& src);
safe_VkPhysicalDeviceMaintenance3Properties();
~safe_VkPhysicalDeviceMaintenance3Properties();
void initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct);
void initialize(const safe_VkPhysicalDeviceMaintenance3Properties* src);
VkPhysicalDeviceMaintenance3Properties *ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties *>(this); }
VkPhysicalDeviceMaintenance3Properties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties const *>(this); }
};
struct safe_VkDescriptorSetLayoutSupport {
VkStructureType sType;
void* pNext;
VkBool32 supported;
safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct);
safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& src);
safe_VkDescriptorSetLayoutSupport& operator=(const safe_VkDescriptorSetLayoutSupport& src);
safe_VkDescriptorSetLayoutSupport();
~safe_VkDescriptorSetLayoutSupport();
void initialize(const VkDescriptorSetLayoutSupport* in_struct);
void initialize(const safe_VkDescriptorSetLayoutSupport* src);
VkDescriptorSetLayoutSupport *ptr() { return reinterpret_cast<VkDescriptorSetLayoutSupport *>(this); }
VkDescriptorSetLayoutSupport const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutSupport const *>(this); }
};
struct safe_VkPhysicalDeviceShaderDrawParametersFeatures {
VkStructureType sType;
void* pNext;
VkBool32 shaderDrawParameters;
safe_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct);
safe_VkPhysicalDeviceShaderDrawParametersFeatures(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& src);
safe_VkPhysicalDeviceShaderDrawParametersFeatures& operator=(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& src);
safe_VkPhysicalDeviceShaderDrawParametersFeatures();
~safe_VkPhysicalDeviceShaderDrawParametersFeatures();
void initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct);
void initialize(const safe_VkPhysicalDeviceShaderDrawParametersFeatures* src);
VkPhysicalDeviceShaderDrawParametersFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures *>(this); }
VkPhysicalDeviceShaderDrawParametersFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures const *>(this); }
};
struct safe_VkSwapchainCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkSwapchainCreateFlagsKHR flags;
VkSurfaceKHR surface;
uint32_t minImageCount;
VkFormat imageFormat;
VkColorSpaceKHR imageColorSpace;
VkExtent2D imageExtent;
uint32_t imageArrayLayers;
VkImageUsageFlags imageUsage;
VkSharingMode imageSharingMode;
uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices;
VkSurfaceTransformFlagBitsKHR preTransform;
VkCompositeAlphaFlagBitsKHR compositeAlpha;
VkPresentModeKHR presentMode;
VkBool32 clipped;
VkSwapchainKHR oldSwapchain;
safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct);
safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& src);
safe_VkSwapchainCreateInfoKHR& operator=(const safe_VkSwapchainCreateInfoKHR& src);
safe_VkSwapchainCreateInfoKHR();
~safe_VkSwapchainCreateInfoKHR();
void initialize(const VkSwapchainCreateInfoKHR* in_struct);
void initialize(const safe_VkSwapchainCreateInfoKHR* src);
VkSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkSwapchainCreateInfoKHR *>(this); }
VkSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkSwapchainCreateInfoKHR const *>(this); }
};
struct safe_VkPresentInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t waitSemaphoreCount;
VkSemaphore* pWaitSemaphores;
uint32_t swapchainCount;
VkSwapchainKHR* pSwapchains;
const uint32_t* pImageIndices;
VkResult* pResults;
safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct);
safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& src);
safe_VkPresentInfoKHR& operator=(const safe_VkPresentInfoKHR& src);
safe_VkPresentInfoKHR();
~safe_VkPresentInfoKHR();
void initialize(const VkPresentInfoKHR* in_struct);
void initialize(const safe_VkPresentInfoKHR* src);
VkPresentInfoKHR *ptr() { return reinterpret_cast<VkPresentInfoKHR *>(this); }
VkPresentInfoKHR const *ptr() const { return reinterpret_cast<VkPresentInfoKHR const *>(this); }
};
struct safe_VkImageSwapchainCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkSwapchainKHR swapchain;
safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct);
safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& src);
safe_VkImageSwapchainCreateInfoKHR& operator=(const safe_VkImageSwapchainCreateInfoKHR& src);
safe_VkImageSwapchainCreateInfoKHR();
~safe_VkImageSwapchainCreateInfoKHR();
void initialize(const VkImageSwapchainCreateInfoKHR* in_struct);
void initialize(const safe_VkImageSwapchainCreateInfoKHR* src);
VkImageSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkImageSwapchainCreateInfoKHR *>(this); }
VkImageSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkImageSwapchainCreateInfoKHR const *>(this); }
};
struct safe_VkBindImageMemorySwapchainInfoKHR {
VkStructureType sType;
const void* pNext;
VkSwapchainKHR swapchain;
uint32_t imageIndex;
safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct);
safe_VkBindImageMemorySwapchainInfoKHR(const safe_VkBindImageMemorySwapchainInfoKHR& src);
safe_VkBindImageMemorySwapchainInfoKHR& operator=(const safe_VkBindImageMemorySwapchainInfoKHR& src);
safe_VkBindImageMemorySwapchainInfoKHR();
~safe_VkBindImageMemorySwapchainInfoKHR();
void initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct);
void initialize(const safe_VkBindImageMemorySwapchainInfoKHR* src);
VkBindImageMemorySwapchainInfoKHR *ptr() { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>(this); }
VkBindImageMemorySwapchainInfoKHR const *ptr() const { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR const *>(this); }
};
struct safe_VkAcquireNextImageInfoKHR {
VkStructureType sType;
const void* pNext;
VkSwapchainKHR swapchain;
uint64_t timeout;
VkSemaphore semaphore;
VkFence fence;
uint32_t deviceMask;
safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct);
safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& src);
safe_VkAcquireNextImageInfoKHR& operator=(const safe_VkAcquireNextImageInfoKHR& src);
safe_VkAcquireNextImageInfoKHR();
~safe_VkAcquireNextImageInfoKHR();
void initialize(const VkAcquireNextImageInfoKHR* in_struct);
void initialize(const safe_VkAcquireNextImageInfoKHR* src);
VkAcquireNextImageInfoKHR *ptr() { return reinterpret_cast<VkAcquireNextImageInfoKHR *>(this); }
VkAcquireNextImageInfoKHR const *ptr() const { return reinterpret_cast<VkAcquireNextImageInfoKHR const *>(this); }
};
struct safe_VkDeviceGroupPresentCapabilitiesKHR {
VkStructureType sType;
const void* pNext;
uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
VkDeviceGroupPresentModeFlagsKHR modes;
safe_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct);
safe_VkDeviceGroupPresentCapabilitiesKHR(const safe_VkDeviceGroupPresentCapabilitiesKHR& src);
safe_VkDeviceGroupPresentCapabilitiesKHR& operator=(const safe_VkDeviceGroupPresentCapabilitiesKHR& src);
safe_VkDeviceGroupPresentCapabilitiesKHR();
~safe_VkDeviceGroupPresentCapabilitiesKHR();
void initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct);
void initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* src);
VkDeviceGroupPresentCapabilitiesKHR *ptr() { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>(this); }
VkDeviceGroupPresentCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR const *>(this); }
};
struct safe_VkDeviceGroupPresentInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t swapchainCount;
const uint32_t* pDeviceMasks;
VkDeviceGroupPresentModeFlagBitsKHR mode;
safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct);
safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& src);
safe_VkDeviceGroupPresentInfoKHR& operator=(const safe_VkDeviceGroupPresentInfoKHR& src);
safe_VkDeviceGroupPresentInfoKHR();
~safe_VkDeviceGroupPresentInfoKHR();
void initialize(const VkDeviceGroupPresentInfoKHR* in_struct);
void initialize(const safe_VkDeviceGroupPresentInfoKHR* src);
VkDeviceGroupPresentInfoKHR *ptr() { return reinterpret_cast<VkDeviceGroupPresentInfoKHR *>(this); }
VkDeviceGroupPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentInfoKHR const *>(this); }
};
struct safe_VkDeviceGroupSwapchainCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkDeviceGroupPresentModeFlagsKHR modes;
safe_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct);
safe_VkDeviceGroupSwapchainCreateInfoKHR(const safe_VkDeviceGroupSwapchainCreateInfoKHR& src);
safe_VkDeviceGroupSwapchainCreateInfoKHR& operator=(const safe_VkDeviceGroupSwapchainCreateInfoKHR& src);
safe_VkDeviceGroupSwapchainCreateInfoKHR();
~safe_VkDeviceGroupSwapchainCreateInfoKHR();
void initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct);
void initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* src);
VkDeviceGroupSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR *>(this); }
VkDeviceGroupSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR const *>(this); }
};
struct safe_VkDisplayPropertiesKHR {
VkDisplayKHR display;
const char* displayName;
VkExtent2D physicalDimensions;
VkExtent2D physicalResolution;
VkSurfaceTransformFlagsKHR supportedTransforms;
VkBool32 planeReorderPossible;
VkBool32 persistentContent;
safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct);
safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& src);
safe_VkDisplayPropertiesKHR& operator=(const safe_VkDisplayPropertiesKHR& src);