| // *** 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); |
| safe_VkDisplayPropertiesKHR(); |
| ~safe_VkDisplayPropertiesKHR(); |
| void initialize(const VkDisplayPropertiesKHR* in_struct); |
| void initialize(const safe_VkDisplayPropertiesKHR* src); |
| VkDisplayPropertiesKHR *ptr() { return reinterpret_cast<VkDisplayPropertiesKHR *>(this); } |
| VkDisplayPropertiesKHR const *ptr() const { return reinterpret_cast<VkDisplayPropertiesKHR const *>(this); } |
| }; |
| |
| struct safe_VkDisplayModeCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkDisplayModeCreateFlagsKHR flags; |
| VkDisplayModeParametersKHR parameters; |
| safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct); |
| safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& src); |
| safe_VkDisplayModeCreateInfoKHR& operator=(const safe_VkDisplayModeCreateInfoKHR& src); |
| safe_VkDisplayModeCreateInfoKHR(); |
| ~safe_VkDisplayModeCreateInfoKHR(); |
| void initialize(const VkDisplayModeCreateInfoKHR* in_struct); |
| void initialize(const safe_VkDisplayModeCreateInfoKHR* src); |
| VkDisplayModeCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplayModeCreateInfoKHR *>(this); } |
| VkDisplayModeCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayModeCreateInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkDisplaySurfaceCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkDisplaySurfaceCreateFlagsKHR flags; |
| VkDisplayModeKHR displayMode; |
| uint32_t planeIndex; |
| uint32_t planeStackIndex; |
| VkSurfaceTransformFlagBitsKHR transform; |
| float globalAlpha; |
| VkDisplayPlaneAlphaFlagBitsKHR alphaMode; |
| VkExtent2D imageExtent; |
| safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct); |
| safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& src); |
| safe_VkDisplaySurfaceCreateInfoKHR& operator=(const safe_VkDisplaySurfaceCreateInfoKHR& src); |
| safe_VkDisplaySurfaceCreateInfoKHR(); |
| ~safe_VkDisplaySurfaceCreateInfoKHR(); |
| void initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct); |
| void initialize(const safe_VkDisplaySurfaceCreateInfoKHR* src); |
| VkDisplaySurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>(this); } |
| VkDisplaySurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkDisplayPresentInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkRect2D srcRect; |
| VkRect2D dstRect; |
| VkBool32 persistent; |
| safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct); |
| safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& src); |
| safe_VkDisplayPresentInfoKHR& operator=(const safe_VkDisplayPresentInfoKHR& src); |
| safe_VkDisplayPresentInfoKHR(); |
| ~safe_VkDisplayPresentInfoKHR(); |
| void initialize(const VkDisplayPresentInfoKHR* in_struct); |
| void initialize(const safe_VkDisplayPresentInfoKHR* src); |
| VkDisplayPresentInfoKHR *ptr() { return reinterpret_cast<VkDisplayPresentInfoKHR *>(this); } |
| VkDisplayPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayPresentInfoKHR const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_XLIB_KHR |
| struct safe_VkXlibSurfaceCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkXlibSurfaceCreateFlagsKHR flags; |
| Display* dpy; |
| Window window; |
| safe_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR* in_struct); |
| safe_VkXlibSurfaceCreateInfoKHR(const safe_VkXlibSurfaceCreateInfoKHR& src); |
| safe_VkXlibSurfaceCreateInfoKHR& operator=(const safe_VkXlibSurfaceCreateInfoKHR& src); |
| safe_VkXlibSurfaceCreateInfoKHR(); |
| ~safe_VkXlibSurfaceCreateInfoKHR(); |
| void initialize(const VkXlibSurfaceCreateInfoKHR* in_struct); |
| void initialize(const safe_VkXlibSurfaceCreateInfoKHR* src); |
| VkXlibSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>(this); } |
| VkXlibSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_XLIB_KHR |
| |
| #ifdef VK_USE_PLATFORM_XCB_KHR |
| struct safe_VkXcbSurfaceCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkXcbSurfaceCreateFlagsKHR flags; |
| xcb_connection_t* connection; |
| xcb_window_t window; |
| safe_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR* in_struct); |
| safe_VkXcbSurfaceCreateInfoKHR(const safe_VkXcbSurfaceCreateInfoKHR& src); |
| safe_VkXcbSurfaceCreateInfoKHR& operator=(const safe_VkXcbSurfaceCreateInfoKHR& src); |
| safe_VkXcbSurfaceCreateInfoKHR(); |
| ~safe_VkXcbSurfaceCreateInfoKHR(); |
| void initialize(const VkXcbSurfaceCreateInfoKHR* in_struct); |
| void initialize(const safe_VkXcbSurfaceCreateInfoKHR* src); |
| VkXcbSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>(this); } |
| VkXcbSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_XCB_KHR |
| |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
| struct safe_VkWaylandSurfaceCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkWaylandSurfaceCreateFlagsKHR flags; |
| struct wl_display* display; |
| struct wl_surface* surface; |
| safe_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR* in_struct); |
| safe_VkWaylandSurfaceCreateInfoKHR(const safe_VkWaylandSurfaceCreateInfoKHR& src); |
| safe_VkWaylandSurfaceCreateInfoKHR& operator=(const safe_VkWaylandSurfaceCreateInfoKHR& src); |
| safe_VkWaylandSurfaceCreateInfoKHR(); |
| ~safe_VkWaylandSurfaceCreateInfoKHR(); |
| void initialize(const VkWaylandSurfaceCreateInfoKHR* in_struct); |
| void initialize(const safe_VkWaylandSurfaceCreateInfoKHR* src); |
| VkWaylandSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>(this); } |
| VkWaylandSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WAYLAND_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| struct safe_VkAndroidSurfaceCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkAndroidSurfaceCreateFlagsKHR flags; |
| struct ANativeWindow* window; |
| safe_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR* in_struct); |
| safe_VkAndroidSurfaceCreateInfoKHR(const safe_VkAndroidSurfaceCreateInfoKHR& src); |
| safe_VkAndroidSurfaceCreateInfoKHR& operator=(const safe_VkAndroidSurfaceCreateInfoKHR& src); |
| safe_VkAndroidSurfaceCreateInfoKHR(); |
| ~safe_VkAndroidSurfaceCreateInfoKHR(); |
| void initialize(const VkAndroidSurfaceCreateInfoKHR* in_struct); |
| void initialize(const safe_VkAndroidSurfaceCreateInfoKHR* src); |
| VkAndroidSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>(this); } |
| VkAndroidSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkWin32SurfaceCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkWin32SurfaceCreateFlagsKHR flags; |
| HINSTANCE hinstance; |
| HWND hwnd; |
| safe_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* in_struct); |
| safe_VkWin32SurfaceCreateInfoKHR(const safe_VkWin32SurfaceCreateInfoKHR& src); |
| safe_VkWin32SurfaceCreateInfoKHR& operator=(const safe_VkWin32SurfaceCreateInfoKHR& src); |
| safe_VkWin32SurfaceCreateInfoKHR(); |
| ~safe_VkWin32SurfaceCreateInfoKHR(); |
| void initialize(const VkWin32SurfaceCreateInfoKHR* in_struct); |
| void initialize(const safe_VkWin32SurfaceCreateInfoKHR* src); |
| VkWin32SurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>(this); } |
| VkWin32SurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkImportMemoryWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkExternalMemoryHandleTypeFlagBits handleType; |
| HANDLE handle; |
| LPCWSTR name; |
| safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct); |
| safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& src); |
| safe_VkImportMemoryWin32HandleInfoKHR& operator=(const safe_VkImportMemoryWin32HandleInfoKHR& src); |
| safe_VkImportMemoryWin32HandleInfoKHR(); |
| ~safe_VkImportMemoryWin32HandleInfoKHR(); |
| void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkImportMemoryWin32HandleInfoKHR* src); |
| VkImportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR *>(this); } |
| VkImportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkExportMemoryWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| const SECURITY_ATTRIBUTES* pAttributes; |
| DWORD dwAccess; |
| LPCWSTR name; |
| safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct); |
| safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& src); |
| safe_VkExportMemoryWin32HandleInfoKHR& operator=(const safe_VkExportMemoryWin32HandleInfoKHR& src); |
| safe_VkExportMemoryWin32HandleInfoKHR(); |
| ~safe_VkExportMemoryWin32HandleInfoKHR(); |
| void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkExportMemoryWin32HandleInfoKHR* src); |
| VkExportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR *>(this); } |
| VkExportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkMemoryWin32HandlePropertiesKHR { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t memoryTypeBits; |
| safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct); |
| safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& src); |
| safe_VkMemoryWin32HandlePropertiesKHR& operator=(const safe_VkMemoryWin32HandlePropertiesKHR& src); |
| safe_VkMemoryWin32HandlePropertiesKHR(); |
| ~safe_VkMemoryWin32HandlePropertiesKHR(); |
| void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct); |
| void initialize(const safe_VkMemoryWin32HandlePropertiesKHR* src); |
| VkMemoryWin32HandlePropertiesKHR *ptr() { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>(this); } |
| VkMemoryWin32HandlePropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkMemoryGetWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceMemory memory; |
| VkExternalMemoryHandleTypeFlagBits handleType; |
| safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct); |
| safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& src); |
| safe_VkMemoryGetWin32HandleInfoKHR& operator=(const safe_VkMemoryGetWin32HandleInfoKHR& src); |
| safe_VkMemoryGetWin32HandleInfoKHR(); |
| ~safe_VkMemoryGetWin32HandleInfoKHR(); |
| void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkMemoryGetWin32HandleInfoKHR* src); |
| VkMemoryGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR *>(this); } |
| VkMemoryGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| struct safe_VkImportMemoryFdInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkExternalMemoryHandleTypeFlagBits handleType; |
| int fd; |
| safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct); |
| safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& src); |
| safe_VkImportMemoryFdInfoKHR& operator=(const safe_VkImportMemoryFdInfoKHR& src); |
| safe_VkImportMemoryFdInfoKHR(); |
| ~safe_VkImportMemoryFdInfoKHR(); |
| void initialize(const VkImportMemoryFdInfoKHR* in_struct); |
| void initialize(const safe_VkImportMemoryFdInfoKHR* src); |
| VkImportMemoryFdInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryFdInfoKHR *>(this); } |
| VkImportMemoryFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryFdInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkMemoryFdPropertiesKHR { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t memoryTypeBits; |
| safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct); |
| safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& src); |
| safe_VkMemoryFdPropertiesKHR& operator=(const safe_VkMemoryFdPropertiesKHR& src); |
| safe_VkMemoryFdPropertiesKHR(); |
| ~safe_VkMemoryFdPropertiesKHR(); |
| void initialize(const VkMemoryFdPropertiesKHR* in_struct); |
| void initialize(const safe_VkMemoryFdPropertiesKHR* src); |
| VkMemoryFdPropertiesKHR *ptr() { return reinterpret_cast<VkMemoryFdPropertiesKHR *>(this); } |
| VkMemoryFdPropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryFdPropertiesKHR const *>(this); } |
| }; |
| |
| struct safe_VkMemoryGetFdInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceMemory memory; |
| VkExternalMemoryHandleTypeFlagBits handleType; |
| safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct); |
| safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& src); |
| safe_VkMemoryGetFdInfoKHR& operator=(const safe_VkMemoryGetFdInfoKHR& src); |
| safe_VkMemoryGetFdInfoKHR(); |
| ~safe_VkMemoryGetFdInfoKHR(); |
| void initialize(const VkMemoryGetFdInfoKHR* in_struct); |
| void initialize(const safe_VkMemoryGetFdInfoKHR* src); |
| VkMemoryGetFdInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetFdInfoKHR *>(this); } |
| VkMemoryGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetFdInfoKHR const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t acquireCount; |
| VkDeviceMemory* pAcquireSyncs; |
| const uint64_t* pAcquireKeys; |
| const uint32_t* pAcquireTimeouts; |
| uint32_t releaseCount; |
| VkDeviceMemory* pReleaseSyncs; |
| const uint64_t* pReleaseKeys; |
| safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct); |
| safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& src); |
| safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& src); |
| safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); |
| ~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); |
| void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct); |
| void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* src); |
| VkWin32KeyedMutexAcquireReleaseInfoKHR *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR *>(this); } |
| VkWin32KeyedMutexAcquireReleaseInfoKHR const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkImportSemaphoreWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkSemaphore semaphore; |
| VkSemaphoreImportFlags flags; |
| VkExternalSemaphoreHandleTypeFlagBits handleType; |
| HANDLE handle; |
| LPCWSTR name; |
| safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct); |
| safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& src); |
| safe_VkImportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& src); |
| safe_VkImportSemaphoreWin32HandleInfoKHR(); |
| ~safe_VkImportSemaphoreWin32HandleInfoKHR(); |
| void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* src); |
| VkImportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR *>(this); } |
| VkImportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkExportSemaphoreWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| const SECURITY_ATTRIBUTES* pAttributes; |
| DWORD dwAccess; |
| LPCWSTR name; |
| safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct); |
| safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& src); |
| safe_VkExportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkExportSemaphoreWin32HandleInfoKHR& src); |
| safe_VkExportSemaphoreWin32HandleInfoKHR(); |
| ~safe_VkExportSemaphoreWin32HandleInfoKHR(); |
| void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* src); |
| VkExportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR *>(this); } |
| VkExportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkD3D12FenceSubmitInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t waitSemaphoreValuesCount; |
| const uint64_t* pWaitSemaphoreValues; |
| uint32_t signalSemaphoreValuesCount; |
| const uint64_t* pSignalSemaphoreValues; |
| safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct); |
| safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& src); |
| safe_VkD3D12FenceSubmitInfoKHR& operator=(const safe_VkD3D12FenceSubmitInfoKHR& src); |
| safe_VkD3D12FenceSubmitInfoKHR(); |
| ~safe_VkD3D12FenceSubmitInfoKHR(); |
| void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct); |
| void initialize(const safe_VkD3D12FenceSubmitInfoKHR* src); |
| VkD3D12FenceSubmitInfoKHR *ptr() { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>(this); } |
| VkD3D12FenceSubmitInfoKHR const *ptr() const { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkSemaphoreGetWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkSemaphore semaphore; |
| VkExternalSemaphoreHandleTypeFlagBits handleType; |
| safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct); |
| safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& src); |
| safe_VkSemaphoreGetWin32HandleInfoKHR& operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& src); |
| safe_VkSemaphoreGetWin32HandleInfoKHR(); |
| ~safe_VkSemaphoreGetWin32HandleInfoKHR(); |
| void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* src); |
| VkSemaphoreGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR *>(this); } |
| VkSemaphoreGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| struct safe_VkImportSemaphoreFdInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkSemaphore semaphore; |
| VkSemaphoreImportFlags flags; |
| VkExternalSemaphoreHandleTypeFlagBits handleType; |
| int fd; |
| safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct); |
| safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& src); |
| safe_VkImportSemaphoreFdInfoKHR& operator=(const safe_VkImportSemaphoreFdInfoKHR& src); |
| safe_VkImportSemaphoreFdInfoKHR(); |
| ~safe_VkImportSemaphoreFdInfoKHR(); |
| void initialize(const VkImportSemaphoreFdInfoKHR* in_struct); |
| void initialize(const safe_VkImportSemaphoreFdInfoKHR* src); |
| VkImportSemaphoreFdInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreFdInfoKHR *>(this); } |
| VkImportSemaphoreFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreFdInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkSemaphoreGetFdInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkSemaphore semaphore; |
| VkExternalSemaphoreHandleTypeFlagBits handleType; |
| safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct); |
| safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& src); |
| safe_VkSemaphoreGetFdInfoKHR& operator=(const safe_VkSemaphoreGetFdInfoKHR& src); |
| safe_VkSemaphoreGetFdInfoKHR(); |
| ~safe_VkSemaphoreGetFdInfoKHR(); |
| void initialize(const VkSemaphoreGetFdInfoKHR* in_struct); |
| void initialize(const safe_VkSemaphoreGetFdInfoKHR* src); |
| VkSemaphoreGetFdInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetFdInfoKHR *>(this); } |
| VkSemaphoreGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetFdInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t maxPushDescriptors; |
| safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct); |
| safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& src); |
| safe_VkPhysicalDevicePushDescriptorPropertiesKHR& operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& src); |
| safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); |
| ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); |
| void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* src); |
| VkPhysicalDevicePushDescriptorPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR *>(this); } |
| VkPhysicalDevicePushDescriptorPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 shaderFloat16; |
| VkBool32 shaderInt8; |
| safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* in_struct); |
| safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& src); |
| safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& src); |
| safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(); |
| ~safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(); |
| void initialize(const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* src); |
| VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *>(this); } |
| VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPresentRegionKHR { |
| uint32_t rectangleCount; |
| const VkRectLayerKHR* pRectangles; |
| safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct); |
| safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& src); |
| safe_VkPresentRegionKHR& operator=(const safe_VkPresentRegionKHR& src); |
| safe_VkPresentRegionKHR(); |
| ~safe_VkPresentRegionKHR(); |
| void initialize(const VkPresentRegionKHR* in_struct); |
| void initialize(const safe_VkPresentRegionKHR* src); |
| VkPresentRegionKHR *ptr() { return reinterpret_cast<VkPresentRegionKHR *>(this); } |
| VkPresentRegionKHR const *ptr() const { return reinterpret_cast<VkPresentRegionKHR const *>(this); } |
| }; |
| |
| struct safe_VkPresentRegionsKHR { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t swapchainCount; |
| safe_VkPresentRegionKHR* pRegions; |
| safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct); |
| safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& src); |
| safe_VkPresentRegionsKHR& operator=(const safe_VkPresentRegionsKHR& src); |
| safe_VkPresentRegionsKHR(); |
| ~safe_VkPresentRegionsKHR(); |
| void initialize(const VkPresentRegionsKHR* in_struct); |
| void initialize(const safe_VkPresentRegionsKHR* src); |
| VkPresentRegionsKHR *ptr() { return reinterpret_cast<VkPresentRegionsKHR *>(this); } |
| VkPresentRegionsKHR const *ptr() const { return reinterpret_cast<VkPresentRegionsKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 imagelessFramebuffer; |
| safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(const VkPhysicalDeviceImagelessFramebufferFeaturesKHR* in_struct); |
| safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& src); |
| safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& operator=(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& src); |
| safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(); |
| ~safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(); |
| void initialize(const VkPhysicalDeviceImagelessFramebufferFeaturesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR* src); |
| VkPhysicalDeviceImagelessFramebufferFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR *>(this); } |
| VkPhysicalDeviceImagelessFramebufferFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR const *>(this); } |
| }; |
| |
| struct safe_VkFramebufferAttachmentImageInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkImageCreateFlags flags; |
| VkImageUsageFlags usage; |
| uint32_t width; |
| uint32_t height; |
| uint32_t layerCount; |
| uint32_t viewFormatCount; |
| const VkFormat* pViewFormats; |
| safe_VkFramebufferAttachmentImageInfoKHR(const VkFramebufferAttachmentImageInfoKHR* in_struct); |
| safe_VkFramebufferAttachmentImageInfoKHR(const safe_VkFramebufferAttachmentImageInfoKHR& src); |
| safe_VkFramebufferAttachmentImageInfoKHR& operator=(const safe_VkFramebufferAttachmentImageInfoKHR& src); |
| safe_VkFramebufferAttachmentImageInfoKHR(); |
| ~safe_VkFramebufferAttachmentImageInfoKHR(); |
| void initialize(const VkFramebufferAttachmentImageInfoKHR* in_struct); |
| void initialize(const safe_VkFramebufferAttachmentImageInfoKHR* src); |
| VkFramebufferAttachmentImageInfoKHR *ptr() { return reinterpret_cast<VkFramebufferAttachmentImageInfoKHR *>(this); } |
| VkFramebufferAttachmentImageInfoKHR const *ptr() const { return reinterpret_cast<VkFramebufferAttachmentImageInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkFramebufferAttachmentsCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t attachmentImageInfoCount; |
| safe_VkFramebufferAttachmentImageInfoKHR* pAttachmentImageInfos; |
| safe_VkFramebufferAttachmentsCreateInfoKHR(const VkFramebufferAttachmentsCreateInfoKHR* in_struct); |
| safe_VkFramebufferAttachmentsCreateInfoKHR(const safe_VkFramebufferAttachmentsCreateInfoKHR& src); |
| safe_VkFramebufferAttachmentsCreateInfoKHR& operator=(const safe_VkFramebufferAttachmentsCreateInfoKHR& src); |
| safe_VkFramebufferAttachmentsCreateInfoKHR(); |
| ~safe_VkFramebufferAttachmentsCreateInfoKHR(); |
| void initialize(const VkFramebufferAttachmentsCreateInfoKHR* in_struct); |
| void initialize(const safe_VkFramebufferAttachmentsCreateInfoKHR* src); |
| VkFramebufferAttachmentsCreateInfoKHR *ptr() { return reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR *>(this); } |
| VkFramebufferAttachmentsCreateInfoKHR const *ptr() const { return reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkRenderPassAttachmentBeginInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t attachmentCount; |
| VkImageView* pAttachments; |
| safe_VkRenderPassAttachmentBeginInfoKHR(const VkRenderPassAttachmentBeginInfoKHR* in_struct); |
| safe_VkRenderPassAttachmentBeginInfoKHR(const safe_VkRenderPassAttachmentBeginInfoKHR& src); |
| safe_VkRenderPassAttachmentBeginInfoKHR& operator=(const safe_VkRenderPassAttachmentBeginInfoKHR& src); |
| safe_VkRenderPassAttachmentBeginInfoKHR(); |
| ~safe_VkRenderPassAttachmentBeginInfoKHR(); |
| void initialize(const VkRenderPassAttachmentBeginInfoKHR* in_struct); |
| void initialize(const safe_VkRenderPassAttachmentBeginInfoKHR* src); |
| VkRenderPassAttachmentBeginInfoKHR *ptr() { return reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR *>(this); } |
| VkRenderPassAttachmentBeginInfoKHR const *ptr() const { return reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkAttachmentDescription2KHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkAttachmentDescriptionFlags flags; |
| VkFormat format; |
| VkSampleCountFlagBits samples; |
| VkAttachmentLoadOp loadOp; |
| VkAttachmentStoreOp storeOp; |
| VkAttachmentLoadOp stencilLoadOp; |
| VkAttachmentStoreOp stencilStoreOp; |
| VkImageLayout initialLayout; |
| VkImageLayout finalLayout; |
| safe_VkAttachmentDescription2KHR(const VkAttachmentDescription2KHR* in_struct); |
| safe_VkAttachmentDescription2KHR(const safe_VkAttachmentDescription2KHR& src); |
| safe_VkAttachmentDescription2KHR& operator=(const safe_VkAttachmentDescription2KHR& src); |
| safe_VkAttachmentDescription2KHR(); |
| ~safe_VkAttachmentDescription2KHR(); |
| void initialize(const VkAttachmentDescription2KHR* in_struct); |
| void initialize(const safe_VkAttachmentDescription2KHR* src); |
| VkAttachmentDescription2KHR *ptr() { return reinterpret_cast<VkAttachmentDescription2KHR *>(this); } |
| VkAttachmentDescription2KHR const *ptr() const { return reinterpret_cast<VkAttachmentDescription2KHR const *>(this); } |
| }; |
| |
| struct safe_VkAttachmentReference2KHR { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t attachment; |
| VkImageLayout layout; |
| VkImageAspectFlags aspectMask; |
| safe_VkAttachmentReference2KHR(const VkAttachmentReference2KHR* in_struct); |
| safe_VkAttachmentReference2KHR(const safe_VkAttachmentReference2KHR& src); |
| safe_VkAttachmentReference2KHR& operator=(const safe_VkAttachmentReference2KHR& src); |
| safe_VkAttachmentReference2KHR(); |
| ~safe_VkAttachmentReference2KHR(); |
| void initialize(const VkAttachmentReference2KHR* in_struct); |
| void initialize(const safe_VkAttachmentReference2KHR* src); |
| VkAttachmentReference2KHR *ptr() { return reinterpret_cast<VkAttachmentReference2KHR *>(this); } |
| VkAttachmentReference2KHR const *ptr() const { return reinterpret_cast<VkAttachmentReference2KHR const *>(this); } |
| }; |
| |
| struct safe_VkSubpassDescription2KHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkSubpassDescriptionFlags flags; |
| VkPipelineBindPoint pipelineBindPoint; |
| uint32_t viewMask; |
| uint32_t inputAttachmentCount; |
| safe_VkAttachmentReference2KHR* pInputAttachments; |
| uint32_t colorAttachmentCount; |
| safe_VkAttachmentReference2KHR* pColorAttachments; |
| safe_VkAttachmentReference2KHR* pResolveAttachments; |
| safe_VkAttachmentReference2KHR* pDepthStencilAttachment; |
| uint32_t preserveAttachmentCount; |
| const uint32_t* pPreserveAttachments; |
| safe_VkSubpassDescription2KHR(const VkSubpassDescription2KHR* in_struct); |
| safe_VkSubpassDescription2KHR(const safe_VkSubpassDescription2KHR& src); |
| safe_VkSubpassDescription2KHR& operator=(const safe_VkSubpassDescription2KHR& src); |
| safe_VkSubpassDescription2KHR(); |
| ~safe_VkSubpassDescription2KHR(); |
| void initialize(const VkSubpassDescription2KHR* in_struct); |
| void initialize(const safe_VkSubpassDescription2KHR* src); |
| VkSubpassDescription2KHR *ptr() { return reinterpret_cast<VkSubpassDescription2KHR *>(this); } |
| VkSubpassDescription2KHR const *ptr() const { return reinterpret_cast<VkSubpassDescription2KHR const *>(this); } |
| }; |
| |
| struct safe_VkSubpassDependency2KHR { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t srcSubpass; |
| uint32_t dstSubpass; |
| VkPipelineStageFlags srcStageMask; |
| VkPipelineStageFlags dstStageMask; |
| VkAccessFlags srcAccessMask; |
| VkAccessFlags dstAccessMask; |
| VkDependencyFlags dependencyFlags; |
| int32_t viewOffset; |
| safe_VkSubpassDependency2KHR(const VkSubpassDependency2KHR* in_struct); |
| safe_VkSubpassDependency2KHR(const safe_VkSubpassDependency2KHR& src); |
| safe_VkSubpassDependency2KHR& operator=(const safe_VkSubpassDependency2KHR& src); |
| safe_VkSubpassDependency2KHR(); |
| ~safe_VkSubpassDependency2KHR(); |
| void initialize(const VkSubpassDependency2KHR* in_struct); |
| void initialize(const safe_VkSubpassDependency2KHR* src); |
| VkSubpassDependency2KHR *ptr() { return reinterpret_cast<VkSubpassDependency2KHR *>(this); } |
| VkSubpassDependency2KHR const *ptr() const { return reinterpret_cast<VkSubpassDependency2KHR const *>(this); } |
| }; |
| |
| struct safe_VkRenderPassCreateInfo2KHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkRenderPassCreateFlags flags; |
| uint32_t attachmentCount; |
| safe_VkAttachmentDescription2KHR* pAttachments; |
| uint32_t subpassCount; |
| safe_VkSubpassDescription2KHR* pSubpasses; |
| uint32_t dependencyCount; |
| safe_VkSubpassDependency2KHR* pDependencies; |
| uint32_t correlatedViewMaskCount; |
| const uint32_t* pCorrelatedViewMasks; |
| safe_VkRenderPassCreateInfo2KHR(const VkRenderPassCreateInfo2KHR* in_struct); |
| safe_VkRenderPassCreateInfo2KHR(const safe_VkRenderPassCreateInfo2KHR& src); |
| safe_VkRenderPassCreateInfo2KHR& operator=(const safe_VkRenderPassCreateInfo2KHR& src); |
| safe_VkRenderPassCreateInfo2KHR(); |
| ~safe_VkRenderPassCreateInfo2KHR(); |
| void initialize(const VkRenderPassCreateInfo2KHR* in_struct); |
| void initialize(const safe_VkRenderPassCreateInfo2KHR* src); |
| VkRenderPassCreateInfo2KHR *ptr() { return reinterpret_cast<VkRenderPassCreateInfo2KHR *>(this); } |
| VkRenderPassCreateInfo2KHR const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo2KHR const *>(this); } |
| }; |
| |
| struct safe_VkSubpassBeginInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkSubpassContents contents; |
| safe_VkSubpassBeginInfoKHR(const VkSubpassBeginInfoKHR* in_struct); |
| safe_VkSubpassBeginInfoKHR(const safe_VkSubpassBeginInfoKHR& src); |
| safe_VkSubpassBeginInfoKHR& operator=(const safe_VkSubpassBeginInfoKHR& src); |
| safe_VkSubpassBeginInfoKHR(); |
| ~safe_VkSubpassBeginInfoKHR(); |
| void initialize(const VkSubpassBeginInfoKHR* in_struct); |
| void initialize(const safe_VkSubpassBeginInfoKHR* src); |
| VkSubpassBeginInfoKHR *ptr() { return reinterpret_cast<VkSubpassBeginInfoKHR *>(this); } |
| VkSubpassBeginInfoKHR const *ptr() const { return reinterpret_cast<VkSubpassBeginInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkSubpassEndInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| safe_VkSubpassEndInfoKHR(const VkSubpassEndInfoKHR* in_struct); |
| safe_VkSubpassEndInfoKHR(const safe_VkSubpassEndInfoKHR& src); |
| safe_VkSubpassEndInfoKHR& operator=(const safe_VkSubpassEndInfoKHR& src); |
| safe_VkSubpassEndInfoKHR(); |
| ~safe_VkSubpassEndInfoKHR(); |
| void initialize(const VkSubpassEndInfoKHR* in_struct); |
| void initialize(const safe_VkSubpassEndInfoKHR* src); |
| VkSubpassEndInfoKHR *ptr() { return reinterpret_cast<VkSubpassEndInfoKHR *>(this); } |
| VkSubpassEndInfoKHR const *ptr() const { return reinterpret_cast<VkSubpassEndInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkSharedPresentSurfaceCapabilitiesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkImageUsageFlags sharedPresentSupportedUsageFlags; |
| safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct); |
| safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& src); |
| safe_VkSharedPresentSurfaceCapabilitiesKHR& operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& src); |
| safe_VkSharedPresentSurfaceCapabilitiesKHR(); |
| ~safe_VkSharedPresentSurfaceCapabilitiesKHR(); |
| void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct); |
| void initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* src); |
| VkSharedPresentSurfaceCapabilitiesKHR *ptr() { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR *>(this); } |
| VkSharedPresentSurfaceCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkImportFenceWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkFence fence; |
| VkFenceImportFlags flags; |
| VkExternalFenceHandleTypeFlagBits handleType; |
| HANDLE handle; |
| LPCWSTR name; |
| safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct); |
| safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& src); |
| safe_VkImportFenceWin32HandleInfoKHR& operator=(const safe_VkImportFenceWin32HandleInfoKHR& src); |
| safe_VkImportFenceWin32HandleInfoKHR(); |
| ~safe_VkImportFenceWin32HandleInfoKHR(); |
| void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkImportFenceWin32HandleInfoKHR* src); |
| VkImportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR *>(this); } |
| VkImportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkExportFenceWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| const SECURITY_ATTRIBUTES* pAttributes; |
| DWORD dwAccess; |
| LPCWSTR name; |
| safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct); |
| safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& src); |
| safe_VkExportFenceWin32HandleInfoKHR& operator=(const safe_VkExportFenceWin32HandleInfoKHR& src); |
| safe_VkExportFenceWin32HandleInfoKHR(); |
| ~safe_VkExportFenceWin32HandleInfoKHR(); |
| void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkExportFenceWin32HandleInfoKHR* src); |
| VkExportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR *>(this); } |
| VkExportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkFenceGetWin32HandleInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkFence fence; |
| VkExternalFenceHandleTypeFlagBits handleType; |
| safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct); |
| safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& src); |
| safe_VkFenceGetWin32HandleInfoKHR& operator=(const safe_VkFenceGetWin32HandleInfoKHR& src); |
| safe_VkFenceGetWin32HandleInfoKHR(); |
| ~safe_VkFenceGetWin32HandleInfoKHR(); |
| void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct); |
| void initialize(const safe_VkFenceGetWin32HandleInfoKHR* src); |
| VkFenceGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR *>(this); } |
| VkFenceGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| struct safe_VkImportFenceFdInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkFence fence; |
| VkFenceImportFlags flags; |
| VkExternalFenceHandleTypeFlagBits handleType; |
| int fd; |
| safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct); |
| safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& src); |
| safe_VkImportFenceFdInfoKHR& operator=(const safe_VkImportFenceFdInfoKHR& src); |
| safe_VkImportFenceFdInfoKHR(); |
| ~safe_VkImportFenceFdInfoKHR(); |
| void initialize(const VkImportFenceFdInfoKHR* in_struct); |
| void initialize(const safe_VkImportFenceFdInfoKHR* src); |
| VkImportFenceFdInfoKHR *ptr() { return reinterpret_cast<VkImportFenceFdInfoKHR *>(this); } |
| VkImportFenceFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceFdInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkFenceGetFdInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkFence fence; |
| VkExternalFenceHandleTypeFlagBits handleType; |
| safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct); |
| safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& src); |
| safe_VkFenceGetFdInfoKHR& operator=(const safe_VkFenceGetFdInfoKHR& src); |
| safe_VkFenceGetFdInfoKHR(); |
| ~safe_VkFenceGetFdInfoKHR(); |
| void initialize(const VkFenceGetFdInfoKHR* in_struct); |
| void initialize(const safe_VkFenceGetFdInfoKHR* src); |
| VkFenceGetFdInfoKHR *ptr() { return reinterpret_cast<VkFenceGetFdInfoKHR *>(this); } |
| VkFenceGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetFdInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceSurfaceInfo2KHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkSurfaceKHR surface; |
| safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct); |
| safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& src); |
| safe_VkPhysicalDeviceSurfaceInfo2KHR& operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& src); |
| safe_VkPhysicalDeviceSurfaceInfo2KHR(); |
| ~safe_VkPhysicalDeviceSurfaceInfo2KHR(); |
| void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* src); |
| VkPhysicalDeviceSurfaceInfo2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR *>(this); } |
| VkPhysicalDeviceSurfaceInfo2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR const *>(this); } |
| }; |
| |
| struct safe_VkSurfaceCapabilities2KHR { |
| VkStructureType sType; |
| void* pNext; |
| VkSurfaceCapabilitiesKHR surfaceCapabilities; |
| safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct); |
| safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& src); |
| safe_VkSurfaceCapabilities2KHR& operator=(const safe_VkSurfaceCapabilities2KHR& src); |
| safe_VkSurfaceCapabilities2KHR(); |
| ~safe_VkSurfaceCapabilities2KHR(); |
| void initialize(const VkSurfaceCapabilities2KHR* in_struct); |
| void initialize(const safe_VkSurfaceCapabilities2KHR* src); |
| VkSurfaceCapabilities2KHR *ptr() { return reinterpret_cast<VkSurfaceCapabilities2KHR *>(this); } |
| VkSurfaceCapabilities2KHR const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2KHR const *>(this); } |
| }; |
| |
| struct safe_VkSurfaceFormat2KHR { |
| VkStructureType sType; |
| void* pNext; |
| VkSurfaceFormatKHR surfaceFormat; |
| safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct); |
| safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& src); |
| safe_VkSurfaceFormat2KHR& operator=(const safe_VkSurfaceFormat2KHR& src); |
| safe_VkSurfaceFormat2KHR(); |
| ~safe_VkSurfaceFormat2KHR(); |
| void initialize(const VkSurfaceFormat2KHR* in_struct); |
| void initialize(const safe_VkSurfaceFormat2KHR* src); |
| VkSurfaceFormat2KHR *ptr() { return reinterpret_cast<VkSurfaceFormat2KHR *>(this); } |
| VkSurfaceFormat2KHR const *ptr() const { return reinterpret_cast<VkSurfaceFormat2KHR const *>(this); } |
| }; |
| |
| struct safe_VkDisplayProperties2KHR { |
| VkStructureType sType; |
| void* pNext; |
| safe_VkDisplayPropertiesKHR displayProperties; |
| safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct); |
| safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& src); |
| safe_VkDisplayProperties2KHR& operator=(const safe_VkDisplayProperties2KHR& src); |
| safe_VkDisplayProperties2KHR(); |
| ~safe_VkDisplayProperties2KHR(); |
| void initialize(const VkDisplayProperties2KHR* in_struct); |
| void initialize(const safe_VkDisplayProperties2KHR* src); |
| VkDisplayProperties2KHR *ptr() { return reinterpret_cast<VkDisplayProperties2KHR *>(this); } |
| VkDisplayProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayProperties2KHR const *>(this); } |
| }; |
| |
| struct safe_VkDisplayPlaneProperties2KHR { |
| VkStructureType sType; |
| void* pNext; |
| VkDisplayPlanePropertiesKHR displayPlaneProperties; |
| safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct); |
| safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& src); |
| safe_VkDisplayPlaneProperties2KHR& operator=(const safe_VkDisplayPlaneProperties2KHR& src); |
| safe_VkDisplayPlaneProperties2KHR(); |
| ~safe_VkDisplayPlaneProperties2KHR(); |
| void initialize(const VkDisplayPlaneProperties2KHR* in_struct); |
| void initialize(const safe_VkDisplayPlaneProperties2KHR* src); |
| VkDisplayPlaneProperties2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneProperties2KHR *>(this); } |
| VkDisplayPlaneProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneProperties2KHR const *>(this); } |
| }; |
| |
| struct safe_VkDisplayModeProperties2KHR { |
| VkStructureType sType; |
| void* pNext; |
| VkDisplayModePropertiesKHR displayModeProperties; |
| safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct); |
| safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& src); |
| safe_VkDisplayModeProperties2KHR& operator=(const safe_VkDisplayModeProperties2KHR& src); |
| safe_VkDisplayModeProperties2KHR(); |
| ~safe_VkDisplayModeProperties2KHR(); |
| void initialize(const VkDisplayModeProperties2KHR* in_struct); |
| void initialize(const safe_VkDisplayModeProperties2KHR* src); |
| VkDisplayModeProperties2KHR *ptr() { return reinterpret_cast<VkDisplayModeProperties2KHR *>(this); } |
| VkDisplayModeProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayModeProperties2KHR const *>(this); } |
| }; |
| |
| struct safe_VkDisplayPlaneInfo2KHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkDisplayModeKHR mode; |
| uint32_t planeIndex; |
| safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct); |
| safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& src); |
| safe_VkDisplayPlaneInfo2KHR& operator=(const safe_VkDisplayPlaneInfo2KHR& src); |
| safe_VkDisplayPlaneInfo2KHR(); |
| ~safe_VkDisplayPlaneInfo2KHR(); |
| void initialize(const VkDisplayPlaneInfo2KHR* in_struct); |
| void initialize(const safe_VkDisplayPlaneInfo2KHR* src); |
| VkDisplayPlaneInfo2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneInfo2KHR *>(this); } |
| VkDisplayPlaneInfo2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneInfo2KHR const *>(this); } |
| }; |
| |
| struct safe_VkDisplayPlaneCapabilities2KHR { |
| VkStructureType sType; |
| void* pNext; |
| VkDisplayPlaneCapabilitiesKHR capabilities; |
| safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct); |
| safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& src); |
| safe_VkDisplayPlaneCapabilities2KHR& operator=(const safe_VkDisplayPlaneCapabilities2KHR& src); |
| safe_VkDisplayPlaneCapabilities2KHR(); |
| ~safe_VkDisplayPlaneCapabilities2KHR(); |
| void initialize(const VkDisplayPlaneCapabilities2KHR* in_struct); |
| void initialize(const safe_VkDisplayPlaneCapabilities2KHR* src); |
| VkDisplayPlaneCapabilities2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>(this); } |
| VkDisplayPlaneCapabilities2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR const *>(this); } |
| }; |
| |
| struct safe_VkImageFormatListCreateInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t viewFormatCount; |
| const VkFormat* pViewFormats; |
| safe_VkImageFormatListCreateInfoKHR(const VkImageFormatListCreateInfoKHR* in_struct); |
| safe_VkImageFormatListCreateInfoKHR(const safe_VkImageFormatListCreateInfoKHR& src); |
| safe_VkImageFormatListCreateInfoKHR& operator=(const safe_VkImageFormatListCreateInfoKHR& src); |
| safe_VkImageFormatListCreateInfoKHR(); |
| ~safe_VkImageFormatListCreateInfoKHR(); |
| void initialize(const VkImageFormatListCreateInfoKHR* in_struct); |
| void initialize(const safe_VkImageFormatListCreateInfoKHR* src); |
| VkImageFormatListCreateInfoKHR *ptr() { return reinterpret_cast<VkImageFormatListCreateInfoKHR *>(this); } |
| VkImageFormatListCreateInfoKHR const *ptr() const { return reinterpret_cast<VkImageFormatListCreateInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDevice8BitStorageFeaturesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 storageBuffer8BitAccess; |
| VkBool32 uniformAndStorageBuffer8BitAccess; |
| VkBool32 storagePushConstant8; |
| safe_VkPhysicalDevice8BitStorageFeaturesKHR(const VkPhysicalDevice8BitStorageFeaturesKHR* in_struct); |
| safe_VkPhysicalDevice8BitStorageFeaturesKHR(const safe_VkPhysicalDevice8BitStorageFeaturesKHR& src); |
| safe_VkPhysicalDevice8BitStorageFeaturesKHR& operator=(const safe_VkPhysicalDevice8BitStorageFeaturesKHR& src); |
| safe_VkPhysicalDevice8BitStorageFeaturesKHR(); |
| ~safe_VkPhysicalDevice8BitStorageFeaturesKHR(); |
| void initialize(const VkPhysicalDevice8BitStorageFeaturesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDevice8BitStorageFeaturesKHR* src); |
| VkPhysicalDevice8BitStorageFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR *>(this); } |
| VkPhysicalDevice8BitStorageFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 shaderBufferInt64Atomics; |
| VkBool32 shaderSharedInt64Atomics; |
| safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* in_struct); |
| safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& src); |
| safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& src); |
| safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(); |
| ~safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(); |
| void initialize(const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* src); |
| VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *>(this); } |
| VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceDriverPropertiesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkDriverIdKHR driverID; |
| char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; |
| char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; |
| VkConformanceVersionKHR conformanceVersion; |
| safe_VkPhysicalDeviceDriverPropertiesKHR(const VkPhysicalDeviceDriverPropertiesKHR* in_struct); |
| safe_VkPhysicalDeviceDriverPropertiesKHR(const safe_VkPhysicalDeviceDriverPropertiesKHR& src); |
| safe_VkPhysicalDeviceDriverPropertiesKHR& operator=(const safe_VkPhysicalDeviceDriverPropertiesKHR& src); |
| safe_VkPhysicalDeviceDriverPropertiesKHR(); |
| ~safe_VkPhysicalDeviceDriverPropertiesKHR(); |
| void initialize(const VkPhysicalDeviceDriverPropertiesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceDriverPropertiesKHR* src); |
| VkPhysicalDeviceDriverPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR *>(this); } |
| VkPhysicalDeviceDriverPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceFloatControlsPropertiesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkShaderFloatControlsIndependenceKHR denormBehaviorIndependence; |
| VkShaderFloatControlsIndependenceKHR roundingModeIndependence; |
| VkBool32 shaderSignedZeroInfNanPreserveFloat16; |
| VkBool32 shaderSignedZeroInfNanPreserveFloat32; |
| VkBool32 shaderSignedZeroInfNanPreserveFloat64; |
| VkBool32 shaderDenormPreserveFloat16; |
| VkBool32 shaderDenormPreserveFloat32; |
| VkBool32 shaderDenormPreserveFloat64; |
| VkBool32 shaderDenormFlushToZeroFloat16; |
| VkBool32 shaderDenormFlushToZeroFloat32; |
| VkBool32 shaderDenormFlushToZeroFloat64; |
| VkBool32 shaderRoundingModeRTEFloat16; |
| VkBool32 shaderRoundingModeRTEFloat32; |
| VkBool32 shaderRoundingModeRTEFloat64; |
| VkBool32 shaderRoundingModeRTZFloat16; |
| VkBool32 shaderRoundingModeRTZFloat32; |
| VkBool32 shaderRoundingModeRTZFloat64; |
| safe_VkPhysicalDeviceFloatControlsPropertiesKHR(const VkPhysicalDeviceFloatControlsPropertiesKHR* in_struct); |
| safe_VkPhysicalDeviceFloatControlsPropertiesKHR(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR& src); |
| safe_VkPhysicalDeviceFloatControlsPropertiesKHR& operator=(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR& src); |
| safe_VkPhysicalDeviceFloatControlsPropertiesKHR(); |
| ~safe_VkPhysicalDeviceFloatControlsPropertiesKHR(); |
| void initialize(const VkPhysicalDeviceFloatControlsPropertiesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR* src); |
| VkPhysicalDeviceFloatControlsPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR *>(this); } |
| VkPhysicalDeviceFloatControlsPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR const *>(this); } |
| }; |
| |
| struct safe_VkSubpassDescriptionDepthStencilResolveKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkResolveModeFlagBitsKHR depthResolveMode; |
| VkResolveModeFlagBitsKHR stencilResolveMode; |
| safe_VkAttachmentReference2KHR* pDepthStencilResolveAttachment; |
| safe_VkSubpassDescriptionDepthStencilResolveKHR(const VkSubpassDescriptionDepthStencilResolveKHR* in_struct); |
| safe_VkSubpassDescriptionDepthStencilResolveKHR(const safe_VkSubpassDescriptionDepthStencilResolveKHR& src); |
| safe_VkSubpassDescriptionDepthStencilResolveKHR& operator=(const safe_VkSubpassDescriptionDepthStencilResolveKHR& src); |
| safe_VkSubpassDescriptionDepthStencilResolveKHR(); |
| ~safe_VkSubpassDescriptionDepthStencilResolveKHR(); |
| void initialize(const VkSubpassDescriptionDepthStencilResolveKHR* in_struct); |
| void initialize(const safe_VkSubpassDescriptionDepthStencilResolveKHR* src); |
| VkSubpassDescriptionDepthStencilResolveKHR *ptr() { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR *>(this); } |
| VkSubpassDescriptionDepthStencilResolveKHR const *ptr() const { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkResolveModeFlagsKHR supportedDepthResolveModes; |
| VkResolveModeFlagsKHR supportedStencilResolveModes; |
| VkBool32 independentResolveNone; |
| VkBool32 independentResolve; |
| safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(const VkPhysicalDeviceDepthStencilResolvePropertiesKHR* in_struct); |
| safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& src); |
| safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& operator=(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& src); |
| safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(); |
| ~safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(); |
| void initialize(const VkPhysicalDeviceDepthStencilResolvePropertiesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR* src); |
| VkPhysicalDeviceDepthStencilResolvePropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR *>(this); } |
| VkPhysicalDeviceDepthStencilResolvePropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 vulkanMemoryModel; |
| VkBool32 vulkanMemoryModelDeviceScope; |
| VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; |
| safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* in_struct); |
| safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& src); |
| safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& src); |
| safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(); |
| ~safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(); |
| void initialize(const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* src); |
| VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *>(this); } |
| VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const *>(this); } |
| }; |
| |
| struct safe_VkSurfaceProtectedCapabilitiesKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 supportsProtected; |
| safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct); |
| safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& src); |
| safe_VkSurfaceProtectedCapabilitiesKHR& operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& src); |
| safe_VkSurfaceProtectedCapabilitiesKHR(); |
| ~safe_VkSurfaceProtectedCapabilitiesKHR(); |
| void initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct); |
| void initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* src); |
| VkSurfaceProtectedCapabilitiesKHR *ptr() { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR *>(this); } |
| VkSurfaceProtectedCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 uniformBufferStandardLayout; |
| safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* in_struct); |
| safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& src); |
| safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& src); |
| safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(); |
| ~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(); |
| void initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* src); |
| VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *>(this); } |
| VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 pipelineExecutableInfo; |
| safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct); |
| safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& src); |
| safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& src); |
| safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); |
| ~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); |
| void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct); |
| void initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* src); |
| VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(this); } |
| VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPipelineInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipeline pipeline; |
| safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct); |
| safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& src); |
| safe_VkPipelineInfoKHR& operator=(const safe_VkPipelineInfoKHR& src); |
| safe_VkPipelineInfoKHR(); |
| ~safe_VkPipelineInfoKHR(); |
| void initialize(const VkPipelineInfoKHR* in_struct); |
| void initialize(const safe_VkPipelineInfoKHR* src); |
| VkPipelineInfoKHR *ptr() { return reinterpret_cast<VkPipelineInfoKHR *>(this); } |
| VkPipelineInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkPipelineExecutablePropertiesKHR { |
| VkStructureType sType; |
| void* pNext; |
| VkShaderStageFlags stages; |
| char name[VK_MAX_DESCRIPTION_SIZE]; |
| char description[VK_MAX_DESCRIPTION_SIZE]; |
| uint32_t subgroupSize; |
| safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct); |
| safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& src); |
| safe_VkPipelineExecutablePropertiesKHR& operator=(const safe_VkPipelineExecutablePropertiesKHR& src); |
| safe_VkPipelineExecutablePropertiesKHR(); |
| ~safe_VkPipelineExecutablePropertiesKHR(); |
| void initialize(const VkPipelineExecutablePropertiesKHR* in_struct); |
| void initialize(const safe_VkPipelineExecutablePropertiesKHR* src); |
| VkPipelineExecutablePropertiesKHR *ptr() { return reinterpret_cast<VkPipelineExecutablePropertiesKHR *>(this); } |
| VkPipelineExecutablePropertiesKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutablePropertiesKHR const *>(this); } |
| }; |
| |
| struct safe_VkPipelineExecutableInfoKHR { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipeline pipeline; |
| uint32_t executableIndex; |
| safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct); |
| safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& src); |
| safe_VkPipelineExecutableInfoKHR& operator=(const safe_VkPipelineExecutableInfoKHR& src); |
| safe_VkPipelineExecutableInfoKHR(); |
| ~safe_VkPipelineExecutableInfoKHR(); |
| void initialize(const VkPipelineExecutableInfoKHR* in_struct); |
| void initialize(const safe_VkPipelineExecutableInfoKHR* src); |
| VkPipelineExecutableInfoKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInfoKHR *>(this); } |
| VkPipelineExecutableInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInfoKHR const *>(this); } |
| }; |
| |
| struct safe_VkPipelineExecutableStatisticKHR { |
| VkStructureType sType; |
| void* pNext; |
| char name[VK_MAX_DESCRIPTION_SIZE]; |
| char description[VK_MAX_DESCRIPTION_SIZE]; |
| VkPipelineExecutableStatisticFormatKHR format; |
| VkPipelineExecutableStatisticValueKHR value; |
| safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct); |
| safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& src); |
| safe_VkPipelineExecutableStatisticKHR& operator=(const safe_VkPipelineExecutableStatisticKHR& src); |
| safe_VkPipelineExecutableStatisticKHR(); |
| ~safe_VkPipelineExecutableStatisticKHR(); |
| void initialize(const VkPipelineExecutableStatisticKHR* in_struct); |
| void initialize(const safe_VkPipelineExecutableStatisticKHR* src); |
| VkPipelineExecutableStatisticKHR *ptr() { return reinterpret_cast<VkPipelineExecutableStatisticKHR *>(this); } |
| VkPipelineExecutableStatisticKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableStatisticKHR const *>(this); } |
| }; |
| |
| struct safe_VkPipelineExecutableInternalRepresentationKHR { |
| VkStructureType sType; |
| void* pNext; |
| char name[VK_MAX_DESCRIPTION_SIZE]; |
| char description[VK_MAX_DESCRIPTION_SIZE]; |
| VkBool32 isText; |
| size_t dataSize; |
| void* pData; |
| safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct); |
| safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& src); |
| safe_VkPipelineExecutableInternalRepresentationKHR& operator=(const safe_VkPipelineExecutableInternalRepresentationKHR& src); |
| safe_VkPipelineExecutableInternalRepresentationKHR(); |
| ~safe_VkPipelineExecutableInternalRepresentationKHR(); |
| void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct); |
| void initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* src); |
| VkPipelineExecutableInternalRepresentationKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>(this); } |
| VkPipelineExecutableInternalRepresentationKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR const *>(this); } |
| }; |
| |
| struct safe_VkDebugReportCallbackCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDebugReportFlagsEXT flags; |
| PFN_vkDebugReportCallbackEXT pfnCallback; |
| void* pUserData; |
| safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct); |
| safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& src); |
| safe_VkDebugReportCallbackCreateInfoEXT& operator=(const safe_VkDebugReportCallbackCreateInfoEXT& src); |
| safe_VkDebugReportCallbackCreateInfoEXT(); |
| ~safe_VkDebugReportCallbackCreateInfoEXT(); |
| void initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct); |
| void initialize(const safe_VkDebugReportCallbackCreateInfoEXT* src); |
| VkDebugReportCallbackCreateInfoEXT *ptr() { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>(this); } |
| VkDebugReportCallbackCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineRasterizationStateRasterizationOrderAMD { |
| VkStructureType sType; |
| const void* pNext; |
| VkRasterizationOrderAMD rasterizationOrder; |
| safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct); |
| safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src); |
| safe_VkPipelineRasterizationStateRasterizationOrderAMD& operator=(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src); |
| safe_VkPipelineRasterizationStateRasterizationOrderAMD(); |
| ~safe_VkPipelineRasterizationStateRasterizationOrderAMD(); |
| void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct); |
| void initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* src); |
| VkPipelineRasterizationStateRasterizationOrderAMD *ptr() { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD *>(this); } |
| VkPipelineRasterizationStateRasterizationOrderAMD const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD const *>(this); } |
| }; |
| |
| struct safe_VkDebugMarkerObjectNameInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDebugReportObjectTypeEXT objectType; |
| uint64_t object; |
| const char* pObjectName; |
| safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct); |
| safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& src); |
| safe_VkDebugMarkerObjectNameInfoEXT& operator=(const safe_VkDebugMarkerObjectNameInfoEXT& src); |
| safe_VkDebugMarkerObjectNameInfoEXT(); |
| ~safe_VkDebugMarkerObjectNameInfoEXT(); |
| void initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct); |
| void initialize(const safe_VkDebugMarkerObjectNameInfoEXT* src); |
| VkDebugMarkerObjectNameInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>(this); } |
| VkDebugMarkerObjectNameInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDebugMarkerObjectTagInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDebugReportObjectTypeEXT objectType; |
| uint64_t object; |
| uint64_t tagName; |
| size_t tagSize; |
| const void* pTag; |
| safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct); |
| safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& src); |
| safe_VkDebugMarkerObjectTagInfoEXT& operator=(const safe_VkDebugMarkerObjectTagInfoEXT& src); |
| safe_VkDebugMarkerObjectTagInfoEXT(); |
| ~safe_VkDebugMarkerObjectTagInfoEXT(); |
| void initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct); |
| void initialize(const safe_VkDebugMarkerObjectTagInfoEXT* src); |
| VkDebugMarkerObjectTagInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>(this); } |
| VkDebugMarkerObjectTagInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDebugMarkerMarkerInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| const char* pMarkerName; |
| float color[4]; |
| safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct); |
| safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& src); |
| safe_VkDebugMarkerMarkerInfoEXT& operator=(const safe_VkDebugMarkerMarkerInfoEXT& src); |
| safe_VkDebugMarkerMarkerInfoEXT(); |
| ~safe_VkDebugMarkerMarkerInfoEXT(); |
| void initialize(const VkDebugMarkerMarkerInfoEXT* in_struct); |
| void initialize(const safe_VkDebugMarkerMarkerInfoEXT* src); |
| VkDebugMarkerMarkerInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>(this); } |
| VkDebugMarkerMarkerInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDedicatedAllocationImageCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 dedicatedAllocation; |
| safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct); |
| safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& src); |
| safe_VkDedicatedAllocationImageCreateInfoNV& operator=(const safe_VkDedicatedAllocationImageCreateInfoNV& src); |
| safe_VkDedicatedAllocationImageCreateInfoNV(); |
| ~safe_VkDedicatedAllocationImageCreateInfoNV(); |
| void initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct); |
| void initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* src); |
| VkDedicatedAllocationImageCreateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>(this); } |
| VkDedicatedAllocationImageCreateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkDedicatedAllocationBufferCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 dedicatedAllocation; |
| safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct); |
| safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& src); |
| safe_VkDedicatedAllocationBufferCreateInfoNV& operator=(const safe_VkDedicatedAllocationBufferCreateInfoNV& src); |
| safe_VkDedicatedAllocationBufferCreateInfoNV(); |
| ~safe_VkDedicatedAllocationBufferCreateInfoNV(); |
| void initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct); |
| void initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* src); |
| VkDedicatedAllocationBufferCreateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>(this); } |
| VkDedicatedAllocationBufferCreateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkDedicatedAllocationMemoryAllocateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkImage image; |
| VkBuffer buffer; |
| safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct); |
| safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src); |
| safe_VkDedicatedAllocationMemoryAllocateInfoNV& operator=(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src); |
| safe_VkDedicatedAllocationMemoryAllocateInfoNV(); |
| ~safe_VkDedicatedAllocationMemoryAllocateInfoNV(); |
| void initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct); |
| void initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* src); |
| VkDedicatedAllocationMemoryAllocateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>(this); } |
| VkDedicatedAllocationMemoryAllocateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 transformFeedback; |
| VkBool32 geometryStreams; |
| safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& src); |
| safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& src); |
| safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(); |
| ~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* src); |
| VkPhysicalDeviceTransformFeedbackFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(this); } |
| VkPhysicalDeviceTransformFeedbackFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t maxTransformFeedbackStreams; |
| uint32_t maxTransformFeedbackBuffers; |
| VkDeviceSize maxTransformFeedbackBufferSize; |
| uint32_t maxTransformFeedbackStreamDataSize; |
| uint32_t maxTransformFeedbackBufferDataSize; |
| uint32_t maxTransformFeedbackBufferDataStride; |
| VkBool32 transformFeedbackQueries; |
| VkBool32 transformFeedbackStreamsLinesTriangles; |
| VkBool32 transformFeedbackRasterizationStreamSelect; |
| VkBool32 transformFeedbackDraw; |
| safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& src); |
| safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& src); |
| safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(); |
| ~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* src); |
| VkPhysicalDeviceTransformFeedbackPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(this); } |
| VkPhysicalDeviceTransformFeedbackPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineRasterizationStateStreamCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineRasterizationStateStreamCreateFlagsEXT flags; |
| uint32_t rasterizationStream; |
| safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct); |
| safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& src); |
| safe_VkPipelineRasterizationStateStreamCreateInfoEXT& operator=(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& src); |
| safe_VkPipelineRasterizationStateStreamCreateInfoEXT(); |
| ~safe_VkPipelineRasterizationStateStreamCreateInfoEXT(); |
| void initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* src); |
| VkPipelineRasterizationStateStreamCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT *>(this); } |
| VkPipelineRasterizationStateStreamCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkImageViewHandleInfoNVX { |
| VkStructureType sType; |
| const void* pNext; |
| VkImageView imageView; |
| VkDescriptorType descriptorType; |
| VkSampler sampler; |
| safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct); |
| safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& src); |
| safe_VkImageViewHandleInfoNVX& operator=(const safe_VkImageViewHandleInfoNVX& src); |
| safe_VkImageViewHandleInfoNVX(); |
| ~safe_VkImageViewHandleInfoNVX(); |
| void initialize(const VkImageViewHandleInfoNVX* in_struct); |
| void initialize(const safe_VkImageViewHandleInfoNVX* src); |
| VkImageViewHandleInfoNVX *ptr() { return reinterpret_cast<VkImageViewHandleInfoNVX *>(this); } |
| VkImageViewHandleInfoNVX const *ptr() const { return reinterpret_cast<VkImageViewHandleInfoNVX const *>(this); } |
| }; |
| |
| struct safe_VkTextureLODGatherFormatPropertiesAMD { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 supportsTextureGatherLODBiasAMD; |
| safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct); |
| safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& src); |
| safe_VkTextureLODGatherFormatPropertiesAMD& operator=(const safe_VkTextureLODGatherFormatPropertiesAMD& src); |
| safe_VkTextureLODGatherFormatPropertiesAMD(); |
| ~safe_VkTextureLODGatherFormatPropertiesAMD(); |
| void initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct); |
| void initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* src); |
| VkTextureLODGatherFormatPropertiesAMD *ptr() { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD *>(this); } |
| VkTextureLODGatherFormatPropertiesAMD const *ptr() const { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_GGP |
| struct safe_VkStreamDescriptorSurfaceCreateInfoGGP { |
| VkStructureType sType; |
| const void* pNext; |
| VkStreamDescriptorSurfaceCreateFlagsGGP flags; |
| GgpStreamDescriptor streamDescriptor; |
| safe_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct); |
| safe_VkStreamDescriptorSurfaceCreateInfoGGP(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& src); |
| safe_VkStreamDescriptorSurfaceCreateInfoGGP& operator=(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& src); |
| safe_VkStreamDescriptorSurfaceCreateInfoGGP(); |
| ~safe_VkStreamDescriptorSurfaceCreateInfoGGP(); |
| void initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct); |
| void initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* src); |
| VkStreamDescriptorSurfaceCreateInfoGGP *ptr() { return reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP *>(this); } |
| VkStreamDescriptorSurfaceCreateInfoGGP const *ptr() const { return reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_GGP |
| |
| struct safe_VkPhysicalDeviceCornerSampledImageFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 cornerSampledImage; |
| safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& src); |
| safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& operator=(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& src); |
| safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(); |
| ~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(); |
| void initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* src); |
| VkPhysicalDeviceCornerSampledImageFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV *>(this); } |
| VkPhysicalDeviceCornerSampledImageFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkExternalMemoryImageCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkExternalMemoryHandleTypeFlagsNV handleTypes; |
| safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct); |
| safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& src); |
| safe_VkExternalMemoryImageCreateInfoNV& operator=(const safe_VkExternalMemoryImageCreateInfoNV& src); |
| safe_VkExternalMemoryImageCreateInfoNV(); |
| ~safe_VkExternalMemoryImageCreateInfoNV(); |
| void initialize(const VkExternalMemoryImageCreateInfoNV* in_struct); |
| void initialize(const safe_VkExternalMemoryImageCreateInfoNV* src); |
| VkExternalMemoryImageCreateInfoNV *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV *>(this); } |
| VkExternalMemoryImageCreateInfoNV const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkExportMemoryAllocateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkExternalMemoryHandleTypeFlagsNV handleTypes; |
| safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct); |
| safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& src); |
| safe_VkExportMemoryAllocateInfoNV& operator=(const safe_VkExportMemoryAllocateInfoNV& src); |
| safe_VkExportMemoryAllocateInfoNV(); |
| ~safe_VkExportMemoryAllocateInfoNV(); |
| void initialize(const VkExportMemoryAllocateInfoNV* in_struct); |
| void initialize(const safe_VkExportMemoryAllocateInfoNV* src); |
| VkExportMemoryAllocateInfoNV *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfoNV *>(this); } |
| VkExportMemoryAllocateInfoNV const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfoNV const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkImportMemoryWin32HandleInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkExternalMemoryHandleTypeFlagsNV handleType; |
| HANDLE handle; |
| safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct); |
| safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& src); |
| safe_VkImportMemoryWin32HandleInfoNV& operator=(const safe_VkImportMemoryWin32HandleInfoNV& src); |
| safe_VkImportMemoryWin32HandleInfoNV(); |
| ~safe_VkImportMemoryWin32HandleInfoNV(); |
| void initialize(const VkImportMemoryWin32HandleInfoNV* in_struct); |
| void initialize(const safe_VkImportMemoryWin32HandleInfoNV* src); |
| VkImportMemoryWin32HandleInfoNV *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV *>(this); } |
| VkImportMemoryWin32HandleInfoNV const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkExportMemoryWin32HandleInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| const SECURITY_ATTRIBUTES* pAttributes; |
| DWORD dwAccess; |
| safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct); |
| safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& src); |
| safe_VkExportMemoryWin32HandleInfoNV& operator=(const safe_VkExportMemoryWin32HandleInfoNV& src); |
| safe_VkExportMemoryWin32HandleInfoNV(); |
| ~safe_VkExportMemoryWin32HandleInfoNV(); |
| void initialize(const VkExportMemoryWin32HandleInfoNV* in_struct); |
| void initialize(const safe_VkExportMemoryWin32HandleInfoNV* src); |
| VkExportMemoryWin32HandleInfoNV *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV *>(this); } |
| VkExportMemoryWin32HandleInfoNV const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkWin32KeyedMutexAcquireReleaseInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t acquireCount; |
| VkDeviceMemory* pAcquireSyncs; |
| const uint64_t* pAcquireKeys; |
| const uint32_t* pAcquireTimeoutMilliseconds; |
| uint32_t releaseCount; |
| VkDeviceMemory* pReleaseSyncs; |
| const uint64_t* pReleaseKeys; |
| safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct); |
| safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& src); |
| safe_VkWin32KeyedMutexAcquireReleaseInfoNV& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& src); |
| safe_VkWin32KeyedMutexAcquireReleaseInfoNV(); |
| ~safe_VkWin32KeyedMutexAcquireReleaseInfoNV(); |
| void initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct); |
| void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* src); |
| VkWin32KeyedMutexAcquireReleaseInfoNV *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV *>(this); } |
| VkWin32KeyedMutexAcquireReleaseInfoNV const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| struct safe_VkValidationFlagsEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t disabledValidationCheckCount; |
| const VkValidationCheckEXT* pDisabledValidationChecks; |
| safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct); |
| safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& src); |
| safe_VkValidationFlagsEXT& operator=(const safe_VkValidationFlagsEXT& src); |
| safe_VkValidationFlagsEXT(); |
| ~safe_VkValidationFlagsEXT(); |
| void initialize(const VkValidationFlagsEXT* in_struct); |
| void initialize(const safe_VkValidationFlagsEXT* src); |
| VkValidationFlagsEXT *ptr() { return reinterpret_cast<VkValidationFlagsEXT *>(this); } |
| VkValidationFlagsEXT const *ptr() const { return reinterpret_cast<VkValidationFlagsEXT const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_VI_NN |
| struct safe_VkViSurfaceCreateInfoNN { |
| VkStructureType sType; |
| const void* pNext; |
| VkViSurfaceCreateFlagsNN flags; |
| void* window; |
| safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct); |
| safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& src); |
| safe_VkViSurfaceCreateInfoNN& operator=(const safe_VkViSurfaceCreateInfoNN& src); |
| safe_VkViSurfaceCreateInfoNN(); |
| ~safe_VkViSurfaceCreateInfoNN(); |
| void initialize(const VkViSurfaceCreateInfoNN* in_struct); |
| void initialize(const safe_VkViSurfaceCreateInfoNN* src); |
| VkViSurfaceCreateInfoNN *ptr() { return reinterpret_cast<VkViSurfaceCreateInfoNN *>(this); } |
| VkViSurfaceCreateInfoNN const *ptr() const { return reinterpret_cast<VkViSurfaceCreateInfoNN const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_VI_NN |
| |
| struct safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 textureCompressionASTC_HDR; |
| safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& src); |
| safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& src); |
| safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(); |
| ~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* src); |
| VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>(this); } |
| VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkImageViewASTCDecodeModeEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkFormat decodeMode; |
| safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct); |
| safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& src); |
| safe_VkImageViewASTCDecodeModeEXT& operator=(const safe_VkImageViewASTCDecodeModeEXT& src); |
| safe_VkImageViewASTCDecodeModeEXT(); |
| ~safe_VkImageViewASTCDecodeModeEXT(); |
| void initialize(const VkImageViewASTCDecodeModeEXT* in_struct); |
| void initialize(const safe_VkImageViewASTCDecodeModeEXT* src); |
| VkImageViewASTCDecodeModeEXT *ptr() { return reinterpret_cast<VkImageViewASTCDecodeModeEXT *>(this); } |
| VkImageViewASTCDecodeModeEXT const *ptr() const { return reinterpret_cast<VkImageViewASTCDecodeModeEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceASTCDecodeFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 decodeModeSharedExponent; |
| safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& src); |
| safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& operator=(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& src); |
| safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(); |
| ~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* src); |
| VkPhysicalDeviceASTCDecodeFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT *>(this); } |
| VkPhysicalDeviceASTCDecodeFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkConditionalRenderingBeginInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkBuffer buffer; |
| VkDeviceSize offset; |
| VkConditionalRenderingFlagsEXT flags; |
| safe_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* in_struct); |
| safe_VkConditionalRenderingBeginInfoEXT(const safe_VkConditionalRenderingBeginInfoEXT& src); |
| safe_VkConditionalRenderingBeginInfoEXT& operator=(const safe_VkConditionalRenderingBeginInfoEXT& src); |
| safe_VkConditionalRenderingBeginInfoEXT(); |
| ~safe_VkConditionalRenderingBeginInfoEXT(); |
| void initialize(const VkConditionalRenderingBeginInfoEXT* in_struct); |
| void initialize(const safe_VkConditionalRenderingBeginInfoEXT* src); |
| VkConditionalRenderingBeginInfoEXT *ptr() { return reinterpret_cast<VkConditionalRenderingBeginInfoEXT *>(this); } |
| VkConditionalRenderingBeginInfoEXT const *ptr() const { return reinterpret_cast<VkConditionalRenderingBeginInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 conditionalRendering; |
| VkBool32 inheritedConditionalRendering; |
| safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& src); |
| safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& operator=(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& src); |
| safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(); |
| ~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* src); |
| VkPhysicalDeviceConditionalRenderingFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(this); } |
| VkPhysicalDeviceConditionalRenderingFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 conditionalRenderingEnable; |
| safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct); |
| safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& src); |
| safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& operator=(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& src); |
| safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(); |
| ~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(); |
| void initialize(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct); |
| void initialize(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* src); |
| VkCommandBufferInheritanceConditionalRenderingInfoEXT *ptr() { return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(this); } |
| VkCommandBufferInheritanceConditionalRenderingInfoEXT const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDeviceGeneratedCommandsFeaturesNVX { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 computeBindingPointSupport; |
| safe_VkDeviceGeneratedCommandsFeaturesNVX(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct); |
| safe_VkDeviceGeneratedCommandsFeaturesNVX(const safe_VkDeviceGeneratedCommandsFeaturesNVX& src); |
| safe_VkDeviceGeneratedCommandsFeaturesNVX& operator=(const safe_VkDeviceGeneratedCommandsFeaturesNVX& src); |
| safe_VkDeviceGeneratedCommandsFeaturesNVX(); |
| ~safe_VkDeviceGeneratedCommandsFeaturesNVX(); |
| void initialize(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct); |
| void initialize(const safe_VkDeviceGeneratedCommandsFeaturesNVX* src); |
| VkDeviceGeneratedCommandsFeaturesNVX *ptr() { return reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX *>(this); } |
| VkDeviceGeneratedCommandsFeaturesNVX const *ptr() const { return reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX const *>(this); } |
| }; |
| |
| struct safe_VkDeviceGeneratedCommandsLimitsNVX { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t maxIndirectCommandsLayoutTokenCount; |
| uint32_t maxObjectEntryCounts; |
| uint32_t minSequenceCountBufferOffsetAlignment; |
| uint32_t minSequenceIndexBufferOffsetAlignment; |
| uint32_t minCommandsTokenBufferOffsetAlignment; |
| safe_VkDeviceGeneratedCommandsLimitsNVX(const VkDeviceGeneratedCommandsLimitsNVX* in_struct); |
| safe_VkDeviceGeneratedCommandsLimitsNVX(const safe_VkDeviceGeneratedCommandsLimitsNVX& src); |
| safe_VkDeviceGeneratedCommandsLimitsNVX& operator=(const safe_VkDeviceGeneratedCommandsLimitsNVX& src); |
| safe_VkDeviceGeneratedCommandsLimitsNVX(); |
| ~safe_VkDeviceGeneratedCommandsLimitsNVX(); |
| void initialize(const VkDeviceGeneratedCommandsLimitsNVX* in_struct); |
| void initialize(const safe_VkDeviceGeneratedCommandsLimitsNVX* src); |
| VkDeviceGeneratedCommandsLimitsNVX *ptr() { return reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX *>(this); } |
| VkDeviceGeneratedCommandsLimitsNVX const *ptr() const { return reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX const *>(this); } |
| }; |
| |
| struct safe_VkIndirectCommandsLayoutCreateInfoNVX { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineBindPoint pipelineBindPoint; |
| VkIndirectCommandsLayoutUsageFlagsNVX flags; |
| uint32_t tokenCount; |
| const VkIndirectCommandsLayoutTokenNVX* pTokens; |
| safe_VkIndirectCommandsLayoutCreateInfoNVX(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct); |
| safe_VkIndirectCommandsLayoutCreateInfoNVX(const safe_VkIndirectCommandsLayoutCreateInfoNVX& src); |
| safe_VkIndirectCommandsLayoutCreateInfoNVX& operator=(const safe_VkIndirectCommandsLayoutCreateInfoNVX& src); |
| safe_VkIndirectCommandsLayoutCreateInfoNVX(); |
| ~safe_VkIndirectCommandsLayoutCreateInfoNVX(); |
| void initialize(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct); |
| void initialize(const safe_VkIndirectCommandsLayoutCreateInfoNVX* src); |
| VkIndirectCommandsLayoutCreateInfoNVX *ptr() { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX *>(this); } |
| VkIndirectCommandsLayoutCreateInfoNVX const *ptr() const { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX const *>(this); } |
| }; |
| |
| struct safe_VkCmdProcessCommandsInfoNVX { |
| VkStructureType sType; |
| const void* pNext; |
| VkObjectTableNVX objectTable; |
| VkIndirectCommandsLayoutNVX indirectCommandsLayout; |
| uint32_t indirectCommandsTokenCount; |
| VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; |
| uint32_t maxSequencesCount; |
| VkCommandBuffer targetCommandBuffer; |
| VkBuffer sequencesCountBuffer; |
| VkDeviceSize sequencesCountOffset; |
| VkBuffer sequencesIndexBuffer; |
| VkDeviceSize sequencesIndexOffset; |
| safe_VkCmdProcessCommandsInfoNVX(const VkCmdProcessCommandsInfoNVX* in_struct); |
| safe_VkCmdProcessCommandsInfoNVX(const safe_VkCmdProcessCommandsInfoNVX& src); |
| safe_VkCmdProcessCommandsInfoNVX& operator=(const safe_VkCmdProcessCommandsInfoNVX& src); |
| safe_VkCmdProcessCommandsInfoNVX(); |
| ~safe_VkCmdProcessCommandsInfoNVX(); |
| void initialize(const VkCmdProcessCommandsInfoNVX* in_struct); |
| void initialize(const safe_VkCmdProcessCommandsInfoNVX* src); |
| VkCmdProcessCommandsInfoNVX *ptr() { return reinterpret_cast<VkCmdProcessCommandsInfoNVX *>(this); } |
| VkCmdProcessCommandsInfoNVX const *ptr() const { return reinterpret_cast<VkCmdProcessCommandsInfoNVX const *>(this); } |
| }; |
| |
| struct safe_VkCmdReserveSpaceForCommandsInfoNVX { |
| VkStructureType sType; |
| const void* pNext; |
| VkObjectTableNVX objectTable; |
| VkIndirectCommandsLayoutNVX indirectCommandsLayout; |
| uint32_t maxSequencesCount; |
| safe_VkCmdReserveSpaceForCommandsInfoNVX(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct); |
| safe_VkCmdReserveSpaceForCommandsInfoNVX(const safe_VkCmdReserveSpaceForCommandsInfoNVX& src); |
| safe_VkCmdReserveSpaceForCommandsInfoNVX& operator=(const safe_VkCmdReserveSpaceForCommandsInfoNVX& src); |
| safe_VkCmdReserveSpaceForCommandsInfoNVX(); |
| ~safe_VkCmdReserveSpaceForCommandsInfoNVX(); |
| void initialize(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct); |
| void initialize(const safe_VkCmdReserveSpaceForCommandsInfoNVX* src); |
| VkCmdReserveSpaceForCommandsInfoNVX *ptr() { return reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX *>(this); } |
| VkCmdReserveSpaceForCommandsInfoNVX const *ptr() const { return reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX const *>(this); } |
| }; |
| |
| struct safe_VkObjectTableCreateInfoNVX { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t objectCount; |
| const VkObjectEntryTypeNVX* pObjectEntryTypes; |
| const uint32_t* pObjectEntryCounts; |
| const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; |
| uint32_t maxUniformBuffersPerDescriptor; |
| uint32_t maxStorageBuffersPerDescriptor; |
| uint32_t maxStorageImagesPerDescriptor; |
| uint32_t maxSampledImagesPerDescriptor; |
| uint32_t maxPipelineLayouts; |
| safe_VkObjectTableCreateInfoNVX(const VkObjectTableCreateInfoNVX* in_struct); |
| safe_VkObjectTableCreateInfoNVX(const safe_VkObjectTableCreateInfoNVX& src); |
| safe_VkObjectTableCreateInfoNVX& operator=(const safe_VkObjectTableCreateInfoNVX& src); |
| safe_VkObjectTableCreateInfoNVX(); |
| ~safe_VkObjectTableCreateInfoNVX(); |
| void initialize(const VkObjectTableCreateInfoNVX* in_struct); |
| void initialize(const safe_VkObjectTableCreateInfoNVX* src); |
| VkObjectTableCreateInfoNVX *ptr() { return reinterpret_cast<VkObjectTableCreateInfoNVX *>(this); } |
| VkObjectTableCreateInfoNVX const *ptr() const { return reinterpret_cast<VkObjectTableCreateInfoNVX const *>(this); } |
| }; |
| |
| struct safe_VkPipelineViewportWScalingStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 viewportWScalingEnable; |
| uint32_t viewportCount; |
| const VkViewportWScalingNV* pViewportWScalings; |
| safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct); |
| safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& src); |
| safe_VkPipelineViewportWScalingStateCreateInfoNV& operator=(const safe_VkPipelineViewportWScalingStateCreateInfoNV& src); |
| safe_VkPipelineViewportWScalingStateCreateInfoNV(); |
| ~safe_VkPipelineViewportWScalingStateCreateInfoNV(); |
| void initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* src); |
| VkPipelineViewportWScalingStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV *>(this); } |
| VkPipelineViewportWScalingStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkSurfaceCapabilities2EXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t minImageCount; |
| uint32_t maxImageCount; |
| VkExtent2D currentExtent; |
| VkExtent2D minImageExtent; |
| VkExtent2D maxImageExtent; |
| uint32_t maxImageArrayLayers; |
| VkSurfaceTransformFlagsKHR supportedTransforms; |
| VkSurfaceTransformFlagBitsKHR currentTransform; |
| VkCompositeAlphaFlagsKHR supportedCompositeAlpha; |
| VkImageUsageFlags supportedUsageFlags; |
| VkSurfaceCounterFlagsEXT supportedSurfaceCounters; |
| safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct); |
| safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& src); |
| safe_VkSurfaceCapabilities2EXT& operator=(const safe_VkSurfaceCapabilities2EXT& src); |
| safe_VkSurfaceCapabilities2EXT(); |
| ~safe_VkSurfaceCapabilities2EXT(); |
| void initialize(const VkSurfaceCapabilities2EXT* in_struct); |
| void initialize(const safe_VkSurfaceCapabilities2EXT* src); |
| VkSurfaceCapabilities2EXT *ptr() { return reinterpret_cast<VkSurfaceCapabilities2EXT *>(this); } |
| VkSurfaceCapabilities2EXT const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2EXT const *>(this); } |
| }; |
| |
| struct safe_VkDisplayPowerInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDisplayPowerStateEXT powerState; |
| safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct); |
| safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& src); |
| safe_VkDisplayPowerInfoEXT& operator=(const safe_VkDisplayPowerInfoEXT& src); |
| safe_VkDisplayPowerInfoEXT(); |
| ~safe_VkDisplayPowerInfoEXT(); |
| void initialize(const VkDisplayPowerInfoEXT* in_struct); |
| void initialize(const safe_VkDisplayPowerInfoEXT* src); |
| VkDisplayPowerInfoEXT *ptr() { return reinterpret_cast<VkDisplayPowerInfoEXT *>(this); } |
| VkDisplayPowerInfoEXT const *ptr() const { return reinterpret_cast<VkDisplayPowerInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDeviceEventInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceEventTypeEXT deviceEvent; |
| safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct); |
| safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& src); |
| safe_VkDeviceEventInfoEXT& operator=(const safe_VkDeviceEventInfoEXT& src); |
| safe_VkDeviceEventInfoEXT(); |
| ~safe_VkDeviceEventInfoEXT(); |
| void initialize(const VkDeviceEventInfoEXT* in_struct); |
| void initialize(const safe_VkDeviceEventInfoEXT* src); |
| VkDeviceEventInfoEXT *ptr() { return reinterpret_cast<VkDeviceEventInfoEXT *>(this); } |
| VkDeviceEventInfoEXT const *ptr() const { return reinterpret_cast<VkDeviceEventInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDisplayEventInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDisplayEventTypeEXT displayEvent; |
| safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct); |
| safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& src); |
| safe_VkDisplayEventInfoEXT& operator=(const safe_VkDisplayEventInfoEXT& src); |
| safe_VkDisplayEventInfoEXT(); |
| ~safe_VkDisplayEventInfoEXT(); |
| void initialize(const VkDisplayEventInfoEXT* in_struct); |
| void initialize(const safe_VkDisplayEventInfoEXT* src); |
| VkDisplayEventInfoEXT *ptr() { return reinterpret_cast<VkDisplayEventInfoEXT *>(this); } |
| VkDisplayEventInfoEXT const *ptr() const { return reinterpret_cast<VkDisplayEventInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkSwapchainCounterCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkSurfaceCounterFlagsEXT surfaceCounters; |
| safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct); |
| safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& src); |
| safe_VkSwapchainCounterCreateInfoEXT& operator=(const safe_VkSwapchainCounterCreateInfoEXT& src); |
| safe_VkSwapchainCounterCreateInfoEXT(); |
| ~safe_VkSwapchainCounterCreateInfoEXT(); |
| void initialize(const VkSwapchainCounterCreateInfoEXT* in_struct); |
| void initialize(const safe_VkSwapchainCounterCreateInfoEXT* src); |
| VkSwapchainCounterCreateInfoEXT *ptr() { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT *>(this); } |
| VkSwapchainCounterCreateInfoEXT const *ptr() const { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPresentTimesInfoGOOGLE { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t swapchainCount; |
| const VkPresentTimeGOOGLE* pTimes; |
| safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct); |
| safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& src); |
| safe_VkPresentTimesInfoGOOGLE& operator=(const safe_VkPresentTimesInfoGOOGLE& src); |
| safe_VkPresentTimesInfoGOOGLE(); |
| ~safe_VkPresentTimesInfoGOOGLE(); |
| void initialize(const VkPresentTimesInfoGOOGLE* in_struct); |
| void initialize(const safe_VkPresentTimesInfoGOOGLE* src); |
| VkPresentTimesInfoGOOGLE *ptr() { return reinterpret_cast<VkPresentTimesInfoGOOGLE *>(this); } |
| VkPresentTimesInfoGOOGLE const *ptr() const { return reinterpret_cast<VkPresentTimesInfoGOOGLE const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 perViewPositionAllComponents; |
| safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct); |
| safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& src); |
| safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& src); |
| safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(); |
| ~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(); |
| void initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct); |
| void initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* src); |
| VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(this); } |
| VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *>(this); } |
| }; |
| |
| struct safe_VkPipelineViewportSwizzleStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineViewportSwizzleStateCreateFlagsNV flags; |
| uint32_t viewportCount; |
| const VkViewportSwizzleNV* pViewportSwizzles; |
| safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct); |
| safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& src); |
| safe_VkPipelineViewportSwizzleStateCreateInfoNV& operator=(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& src); |
| safe_VkPipelineViewportSwizzleStateCreateInfoNV(); |
| ~safe_VkPipelineViewportSwizzleStateCreateInfoNV(); |
| void initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* src); |
| VkPipelineViewportSwizzleStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV *>(this); } |
| VkPipelineViewportSwizzleStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t maxDiscardRectangles; |
| safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& src); |
| safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& operator=(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& src); |
| safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(); |
| ~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(); |
| void initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* src); |
| VkPhysicalDeviceDiscardRectanglePropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(this); } |
| VkPhysicalDeviceDiscardRectanglePropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineDiscardRectangleStateCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineDiscardRectangleStateCreateFlagsEXT flags; |
| VkDiscardRectangleModeEXT discardRectangleMode; |
| uint32_t discardRectangleCount; |
| const VkRect2D* pDiscardRectangles; |
| safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct); |
| safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& src); |
| safe_VkPipelineDiscardRectangleStateCreateInfoEXT& operator=(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& src); |
| safe_VkPipelineDiscardRectangleStateCreateInfoEXT(); |
| ~safe_VkPipelineDiscardRectangleStateCreateInfoEXT(); |
| void initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* src); |
| VkPipelineDiscardRectangleStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT *>(this); } |
| VkPipelineDiscardRectangleStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| float primitiveOverestimationSize; |
| float maxExtraPrimitiveOverestimationSize; |
| float extraPrimitiveOverestimationSizeGranularity; |
| VkBool32 primitiveUnderestimation; |
| VkBool32 conservativePointAndLineRasterization; |
| VkBool32 degenerateTrianglesRasterized; |
| VkBool32 degenerateLinesRasterized; |
| VkBool32 fullyCoveredFragmentShaderInputVariable; |
| VkBool32 conservativeRasterizationPostDepthCoverage; |
| safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& src); |
| safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& operator=(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& src); |
| safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(); |
| ~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* src); |
| VkPhysicalDeviceConservativeRasterizationPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(this); } |
| VkPhysicalDeviceConservativeRasterizationPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineRasterizationConservativeStateCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; |
| VkConservativeRasterizationModeEXT conservativeRasterizationMode; |
| float extraPrimitiveOverestimationSize; |
| safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct); |
| safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& src); |
| safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& src); |
| safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(); |
| ~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(); |
| void initialize(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* src); |
| VkPipelineRasterizationConservativeStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT *>(this); } |
| VkPipelineRasterizationConservativeStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 depthClipEnable; |
| safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& src); |
| safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& src); |
| safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(); |
| ~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* src); |
| VkPhysicalDeviceDepthClipEnableFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(this); } |
| VkPhysicalDeviceDepthClipEnableFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; |
| VkBool32 depthClipEnable; |
| safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct); |
| safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& src); |
| safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& src); |
| safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(); |
| ~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(); |
| void initialize(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* src); |
| VkPipelineRasterizationDepthClipStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(this); } |
| VkPipelineRasterizationDepthClipStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkHdrMetadataEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkXYColorEXT displayPrimaryRed; |
| VkXYColorEXT displayPrimaryGreen; |
| VkXYColorEXT displayPrimaryBlue; |
| VkXYColorEXT whitePoint; |
| float maxLuminance; |
| float minLuminance; |
| float maxContentLightLevel; |
| float maxFrameAverageLightLevel; |
| safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct); |
| safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& src); |
| safe_VkHdrMetadataEXT& operator=(const safe_VkHdrMetadataEXT& src); |
| safe_VkHdrMetadataEXT(); |
| ~safe_VkHdrMetadataEXT(); |
| void initialize(const VkHdrMetadataEXT* in_struct); |
| void initialize(const safe_VkHdrMetadataEXT* src); |
| VkHdrMetadataEXT *ptr() { return reinterpret_cast<VkHdrMetadataEXT *>(this); } |
| VkHdrMetadataEXT const *ptr() const { return reinterpret_cast<VkHdrMetadataEXT const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_IOS_MVK |
| struct safe_VkIOSSurfaceCreateInfoMVK { |
| VkStructureType sType; |
| const void* pNext; |
| VkIOSSurfaceCreateFlagsMVK flags; |
| const void* pView; |
| safe_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK* in_struct); |
| safe_VkIOSSurfaceCreateInfoMVK(const safe_VkIOSSurfaceCreateInfoMVK& src); |
| safe_VkIOSSurfaceCreateInfoMVK& operator=(const safe_VkIOSSurfaceCreateInfoMVK& src); |
| safe_VkIOSSurfaceCreateInfoMVK(); |
| ~safe_VkIOSSurfaceCreateInfoMVK(); |
| void initialize(const VkIOSSurfaceCreateInfoMVK* in_struct); |
| void initialize(const safe_VkIOSSurfaceCreateInfoMVK* src); |
| VkIOSSurfaceCreateInfoMVK *ptr() { return reinterpret_cast<VkIOSSurfaceCreateInfoMVK *>(this); } |
| VkIOSSurfaceCreateInfoMVK const *ptr() const { return reinterpret_cast<VkIOSSurfaceCreateInfoMVK const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_IOS_MVK |
| |
| #ifdef VK_USE_PLATFORM_MACOS_MVK |
| struct safe_VkMacOSSurfaceCreateInfoMVK { |
| VkStructureType sType; |
| const void* pNext; |
| VkMacOSSurfaceCreateFlagsMVK flags; |
| const void* pView; |
| safe_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* in_struct); |
| safe_VkMacOSSurfaceCreateInfoMVK(const safe_VkMacOSSurfaceCreateInfoMVK& src); |
| safe_VkMacOSSurfaceCreateInfoMVK& operator=(const safe_VkMacOSSurfaceCreateInfoMVK& src); |
| safe_VkMacOSSurfaceCreateInfoMVK(); |
| ~safe_VkMacOSSurfaceCreateInfoMVK(); |
| void initialize(const VkMacOSSurfaceCreateInfoMVK* in_struct); |
| void initialize(const safe_VkMacOSSurfaceCreateInfoMVK* src); |
| VkMacOSSurfaceCreateInfoMVK *ptr() { return reinterpret_cast<VkMacOSSurfaceCreateInfoMVK *>(this); } |
| VkMacOSSurfaceCreateInfoMVK const *ptr() const { return reinterpret_cast<VkMacOSSurfaceCreateInfoMVK const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_MACOS_MVK |
| |
| struct safe_VkDebugUtilsObjectNameInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkObjectType objectType; |
| uint64_t objectHandle; |
| const char* pObjectName; |
| safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct); |
| safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& src); |
| safe_VkDebugUtilsObjectNameInfoEXT& operator=(const safe_VkDebugUtilsObjectNameInfoEXT& src); |
| safe_VkDebugUtilsObjectNameInfoEXT(); |
| ~safe_VkDebugUtilsObjectNameInfoEXT(); |
| void initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct); |
| void initialize(const safe_VkDebugUtilsObjectNameInfoEXT* src); |
| VkDebugUtilsObjectNameInfoEXT *ptr() { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT *>(this); } |
| VkDebugUtilsObjectNameInfoEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDebugUtilsObjectTagInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkObjectType objectType; |
| uint64_t objectHandle; |
| uint64_t tagName; |
| size_t tagSize; |
| const void* pTag; |
| safe_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct); |
| safe_VkDebugUtilsObjectTagInfoEXT(const safe_VkDebugUtilsObjectTagInfoEXT& src); |
| safe_VkDebugUtilsObjectTagInfoEXT& operator=(const safe_VkDebugUtilsObjectTagInfoEXT& src); |
| safe_VkDebugUtilsObjectTagInfoEXT(); |
| ~safe_VkDebugUtilsObjectTagInfoEXT(); |
| void initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct); |
| void initialize(const safe_VkDebugUtilsObjectTagInfoEXT* src); |
| VkDebugUtilsObjectTagInfoEXT *ptr() { return reinterpret_cast<VkDebugUtilsObjectTagInfoEXT *>(this); } |
| VkDebugUtilsObjectTagInfoEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsObjectTagInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDebugUtilsLabelEXT { |
| VkStructureType sType; |
| const void* pNext; |
| const char* pLabelName; |
| float color[4]; |
| safe_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct); |
| safe_VkDebugUtilsLabelEXT(const safe_VkDebugUtilsLabelEXT& src); |
| safe_VkDebugUtilsLabelEXT& operator=(const safe_VkDebugUtilsLabelEXT& src); |
| safe_VkDebugUtilsLabelEXT(); |
| ~safe_VkDebugUtilsLabelEXT(); |
| void initialize(const VkDebugUtilsLabelEXT* in_struct); |
| void initialize(const safe_VkDebugUtilsLabelEXT* src); |
| VkDebugUtilsLabelEXT *ptr() { return reinterpret_cast<VkDebugUtilsLabelEXT *>(this); } |
| VkDebugUtilsLabelEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsLabelEXT const *>(this); } |
| }; |
| |
| struct safe_VkDebugUtilsMessengerCallbackDataEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDebugUtilsMessengerCallbackDataFlagsEXT flags; |
| const char* pMessageIdName; |
| int32_t messageIdNumber; |
| const char* pMessage; |
| uint32_t queueLabelCount; |
| safe_VkDebugUtilsLabelEXT* pQueueLabels; |
| uint32_t cmdBufLabelCount; |
| safe_VkDebugUtilsLabelEXT* pCmdBufLabels; |
| uint32_t objectCount; |
| safe_VkDebugUtilsObjectNameInfoEXT* pObjects; |
| safe_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* in_struct); |
| safe_VkDebugUtilsMessengerCallbackDataEXT(const safe_VkDebugUtilsMessengerCallbackDataEXT& src); |
| safe_VkDebugUtilsMessengerCallbackDataEXT& operator=(const safe_VkDebugUtilsMessengerCallbackDataEXT& src); |
| safe_VkDebugUtilsMessengerCallbackDataEXT(); |
| ~safe_VkDebugUtilsMessengerCallbackDataEXT(); |
| void initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct); |
| void initialize(const safe_VkDebugUtilsMessengerCallbackDataEXT* src); |
| VkDebugUtilsMessengerCallbackDataEXT *ptr() { return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT *>(this); } |
| VkDebugUtilsMessengerCallbackDataEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT const *>(this); } |
| }; |
| |
| struct safe_VkDebugUtilsMessengerCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDebugUtilsMessengerCreateFlagsEXT flags; |
| VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; |
| VkDebugUtilsMessageTypeFlagsEXT messageType; |
| PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; |
| void* pUserData; |
| safe_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* in_struct); |
| safe_VkDebugUtilsMessengerCreateInfoEXT(const safe_VkDebugUtilsMessengerCreateInfoEXT& src); |
| safe_VkDebugUtilsMessengerCreateInfoEXT& operator=(const safe_VkDebugUtilsMessengerCreateInfoEXT& src); |
| safe_VkDebugUtilsMessengerCreateInfoEXT(); |
| ~safe_VkDebugUtilsMessengerCreateInfoEXT(); |
| void initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct); |
| void initialize(const safe_VkDebugUtilsMessengerCreateInfoEXT* src); |
| VkDebugUtilsMessengerCreateInfoEXT *ptr() { return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT *>(this); } |
| VkDebugUtilsMessengerCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| struct safe_VkAndroidHardwareBufferUsageANDROID { |
| VkStructureType sType; |
| void* pNext; |
| uint64_t androidHardwareBufferUsage; |
| safe_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID* in_struct); |
| safe_VkAndroidHardwareBufferUsageANDROID(const safe_VkAndroidHardwareBufferUsageANDROID& src); |
| safe_VkAndroidHardwareBufferUsageANDROID& operator=(const safe_VkAndroidHardwareBufferUsageANDROID& src); |
| safe_VkAndroidHardwareBufferUsageANDROID(); |
| ~safe_VkAndroidHardwareBufferUsageANDROID(); |
| void initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct); |
| void initialize(const safe_VkAndroidHardwareBufferUsageANDROID* src); |
| VkAndroidHardwareBufferUsageANDROID *ptr() { return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID *>(this); } |
| VkAndroidHardwareBufferUsageANDROID const *ptr() const { return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| struct safe_VkAndroidHardwareBufferPropertiesANDROID { |
| VkStructureType sType; |
| void* pNext; |
| VkDeviceSize allocationSize; |
| uint32_t memoryTypeBits; |
| safe_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID* in_struct); |
| safe_VkAndroidHardwareBufferPropertiesANDROID(const safe_VkAndroidHardwareBufferPropertiesANDROID& src); |
| safe_VkAndroidHardwareBufferPropertiesANDROID& operator=(const safe_VkAndroidHardwareBufferPropertiesANDROID& src); |
| safe_VkAndroidHardwareBufferPropertiesANDROID(); |
| ~safe_VkAndroidHardwareBufferPropertiesANDROID(); |
| void initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct); |
| void initialize(const safe_VkAndroidHardwareBufferPropertiesANDROID* src); |
| VkAndroidHardwareBufferPropertiesANDROID *ptr() { return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>(this); } |
| VkAndroidHardwareBufferPropertiesANDROID const *ptr() const { return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| struct safe_VkAndroidHardwareBufferFormatPropertiesANDROID { |
| VkStructureType sType; |
| void* pNext; |
| VkFormat format; |
| uint64_t externalFormat; |
| VkFormatFeatureFlags formatFeatures; |
| VkComponentMapping samplerYcbcrConversionComponents; |
| VkSamplerYcbcrModelConversion suggestedYcbcrModel; |
| VkSamplerYcbcrRange suggestedYcbcrRange; |
| VkChromaLocation suggestedXChromaOffset; |
| VkChromaLocation suggestedYChromaOffset; |
| safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct); |
| safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& src); |
| safe_VkAndroidHardwareBufferFormatPropertiesANDROID& operator=(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& src); |
| safe_VkAndroidHardwareBufferFormatPropertiesANDROID(); |
| ~safe_VkAndroidHardwareBufferFormatPropertiesANDROID(); |
| void initialize(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct); |
| void initialize(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID* src); |
| VkAndroidHardwareBufferFormatPropertiesANDROID *ptr() { return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID *>(this); } |
| VkAndroidHardwareBufferFormatPropertiesANDROID const *ptr() const { return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| struct safe_VkImportAndroidHardwareBufferInfoANDROID { |
| VkStructureType sType; |
| const void* pNext; |
| struct AHardwareBuffer* buffer; |
| safe_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID* in_struct); |
| safe_VkImportAndroidHardwareBufferInfoANDROID(const safe_VkImportAndroidHardwareBufferInfoANDROID& src); |
| safe_VkImportAndroidHardwareBufferInfoANDROID& operator=(const safe_VkImportAndroidHardwareBufferInfoANDROID& src); |
| safe_VkImportAndroidHardwareBufferInfoANDROID(); |
| ~safe_VkImportAndroidHardwareBufferInfoANDROID(); |
| void initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct); |
| void initialize(const safe_VkImportAndroidHardwareBufferInfoANDROID* src); |
| VkImportAndroidHardwareBufferInfoANDROID *ptr() { return reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID *>(this); } |
| VkImportAndroidHardwareBufferInfoANDROID const *ptr() const { return reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| struct safe_VkMemoryGetAndroidHardwareBufferInfoANDROID { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceMemory memory; |
| safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct); |
| safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& src); |
| safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& operator=(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& src); |
| safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(); |
| ~safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(); |
| void initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct); |
| void initialize(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID* src); |
| VkMemoryGetAndroidHardwareBufferInfoANDROID *ptr() { return reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID *>(this); } |
| VkMemoryGetAndroidHardwareBufferInfoANDROID const *ptr() const { return reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| struct safe_VkExternalFormatANDROID { |
| VkStructureType sType; |
| void* pNext; |
| uint64_t externalFormat; |
| safe_VkExternalFormatANDROID(const VkExternalFormatANDROID* in_struct); |
| safe_VkExternalFormatANDROID(const safe_VkExternalFormatANDROID& src); |
| safe_VkExternalFormatANDROID& operator=(const safe_VkExternalFormatANDROID& src); |
| safe_VkExternalFormatANDROID(); |
| ~safe_VkExternalFormatANDROID(); |
| void initialize(const VkExternalFormatANDROID* in_struct); |
| void initialize(const safe_VkExternalFormatANDROID* src); |
| VkExternalFormatANDROID *ptr() { return reinterpret_cast<VkExternalFormatANDROID *>(this); } |
| VkExternalFormatANDROID const *ptr() const { return reinterpret_cast<VkExternalFormatANDROID const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| struct safe_VkSamplerReductionModeCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkSamplerReductionModeEXT reductionMode; |
| safe_VkSamplerReductionModeCreateInfoEXT(const VkSamplerReductionModeCreateInfoEXT* in_struct); |
| safe_VkSamplerReductionModeCreateInfoEXT(const safe_VkSamplerReductionModeCreateInfoEXT& src); |
| safe_VkSamplerReductionModeCreateInfoEXT& operator=(const safe_VkSamplerReductionModeCreateInfoEXT& src); |
| safe_VkSamplerReductionModeCreateInfoEXT(); |
| ~safe_VkSamplerReductionModeCreateInfoEXT(); |
| void initialize(const VkSamplerReductionModeCreateInfoEXT* in_struct); |
| void initialize(const safe_VkSamplerReductionModeCreateInfoEXT* src); |
| VkSamplerReductionModeCreateInfoEXT *ptr() { return reinterpret_cast<VkSamplerReductionModeCreateInfoEXT *>(this); } |
| VkSamplerReductionModeCreateInfoEXT const *ptr() const { return reinterpret_cast<VkSamplerReductionModeCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 filterMinmaxSingleComponentFormats; |
| VkBool32 filterMinmaxImageComponentMapping; |
| safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT& src); |
| safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT& src); |
| safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(); |
| ~safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* src); |
| VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *>(this); } |
| VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 inlineUniformBlock; |
| VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; |
| safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& src); |
| safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& operator=(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& src); |
| safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(); |
| ~safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT* src); |
| VkPhysicalDeviceInlineUniformBlockFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>(this); } |
| VkPhysicalDeviceInlineUniformBlockFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t maxInlineUniformBlockSize; |
| uint32_t maxPerStageDescriptorInlineUniformBlocks; |
| uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; |
| uint32_t maxDescriptorSetInlineUniformBlocks; |
| uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; |
| safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& src); |
| safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& operator=(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& src); |
| safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(); |
| ~safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT* src); |
| VkPhysicalDeviceInlineUniformBlockPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>(this); } |
| VkPhysicalDeviceInlineUniformBlockPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkWriteDescriptorSetInlineUniformBlockEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t dataSize; |
| const void* pData; |
| safe_VkWriteDescriptorSetInlineUniformBlockEXT(const VkWriteDescriptorSetInlineUniformBlockEXT* in_struct); |
| safe_VkWriteDescriptorSetInlineUniformBlockEXT(const safe_VkWriteDescriptorSetInlineUniformBlockEXT& src); |
| safe_VkWriteDescriptorSetInlineUniformBlockEXT& operator=(const safe_VkWriteDescriptorSetInlineUniformBlockEXT& src); |
| safe_VkWriteDescriptorSetInlineUniformBlockEXT(); |
| ~safe_VkWriteDescriptorSetInlineUniformBlockEXT(); |
| void initialize(const VkWriteDescriptorSetInlineUniformBlockEXT* in_struct); |
| void initialize(const safe_VkWriteDescriptorSetInlineUniformBlockEXT* src); |
| VkWriteDescriptorSetInlineUniformBlockEXT *ptr() { return reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT *>(this); } |
| VkWriteDescriptorSetInlineUniformBlockEXT const *ptr() const { return reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT const *>(this); } |
| }; |
| |
| struct safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t maxInlineUniformBlockBindings; |
| safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* in_struct); |
| safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& src); |
| safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& operator=(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& src); |
| safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(); |
| ~safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(); |
| void initialize(const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* in_struct); |
| void initialize(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT* src); |
| VkDescriptorPoolInlineUniformBlockCreateInfoEXT *ptr() { return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>(this); } |
| VkDescriptorPoolInlineUniformBlockCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkSampleLocationsInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkSampleCountFlagBits sampleLocationsPerPixel; |
| VkExtent2D sampleLocationGridSize; |
| uint32_t sampleLocationsCount; |
| const VkSampleLocationEXT* pSampleLocations; |
| safe_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct); |
| safe_VkSampleLocationsInfoEXT(const safe_VkSampleLocationsInfoEXT& src); |
| safe_VkSampleLocationsInfoEXT& operator=(const safe_VkSampleLocationsInfoEXT& src); |
| safe_VkSampleLocationsInfoEXT(); |
| ~safe_VkSampleLocationsInfoEXT(); |
| void initialize(const VkSampleLocationsInfoEXT* in_struct); |
| void initialize(const safe_VkSampleLocationsInfoEXT* src); |
| VkSampleLocationsInfoEXT *ptr() { return reinterpret_cast<VkSampleLocationsInfoEXT *>(this); } |
| VkSampleLocationsInfoEXT const *ptr() const { return reinterpret_cast<VkSampleLocationsInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkRenderPassSampleLocationsBeginInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t attachmentInitialSampleLocationsCount; |
| const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; |
| uint32_t postSubpassSampleLocationsCount; |
| const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; |
| safe_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct); |
| safe_VkRenderPassSampleLocationsBeginInfoEXT(const safe_VkRenderPassSampleLocationsBeginInfoEXT& src); |
| safe_VkRenderPassSampleLocationsBeginInfoEXT& operator=(const safe_VkRenderPassSampleLocationsBeginInfoEXT& src); |
| safe_VkRenderPassSampleLocationsBeginInfoEXT(); |
| ~safe_VkRenderPassSampleLocationsBeginInfoEXT(); |
| void initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct); |
| void initialize(const safe_VkRenderPassSampleLocationsBeginInfoEXT* src); |
| VkRenderPassSampleLocationsBeginInfoEXT *ptr() { return reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT *>(this); } |
| VkRenderPassSampleLocationsBeginInfoEXT const *ptr() const { return reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineSampleLocationsStateCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 sampleLocationsEnable; |
| safe_VkSampleLocationsInfoEXT sampleLocationsInfo; |
| safe_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct); |
| safe_VkPipelineSampleLocationsStateCreateInfoEXT(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& src); |
| safe_VkPipelineSampleLocationsStateCreateInfoEXT& operator=(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& src); |
| safe_VkPipelineSampleLocationsStateCreateInfoEXT(); |
| ~safe_VkPipelineSampleLocationsStateCreateInfoEXT(); |
| void initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineSampleLocationsStateCreateInfoEXT* src); |
| VkPipelineSampleLocationsStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT *>(this); } |
| VkPipelineSampleLocationsStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceSampleLocationsPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkSampleCountFlags sampleLocationSampleCounts; |
| VkExtent2D maxSampleLocationGridSize; |
| float sampleLocationCoordinateRange[2]; |
| uint32_t sampleLocationSubPixelBits; |
| VkBool32 variableSampleLocations; |
| safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& src); |
| safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& operator=(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& src); |
| safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(); |
| ~safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT* src); |
| VkPhysicalDeviceSampleLocationsPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT *>(this); } |
| VkPhysicalDeviceSampleLocationsPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkMultisamplePropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkExtent2D maxSampleLocationGridSize; |
| safe_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct); |
| safe_VkMultisamplePropertiesEXT(const safe_VkMultisamplePropertiesEXT& src); |
| safe_VkMultisamplePropertiesEXT& operator=(const safe_VkMultisamplePropertiesEXT& src); |
| safe_VkMultisamplePropertiesEXT(); |
| ~safe_VkMultisamplePropertiesEXT(); |
| void initialize(const VkMultisamplePropertiesEXT* in_struct); |
| void initialize(const safe_VkMultisamplePropertiesEXT* src); |
| VkMultisamplePropertiesEXT *ptr() { return reinterpret_cast<VkMultisamplePropertiesEXT *>(this); } |
| VkMultisamplePropertiesEXT const *ptr() const { return reinterpret_cast<VkMultisamplePropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 advancedBlendCoherentOperations; |
| safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& src); |
| safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& src); |
| safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(); |
| ~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* src); |
| VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(this); } |
| VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t advancedBlendMaxColorAttachments; |
| VkBool32 advancedBlendIndependentBlend; |
| VkBool32 advancedBlendNonPremultipliedSrcColor; |
| VkBool32 advancedBlendNonPremultipliedDstColor; |
| VkBool32 advancedBlendCorrelatedOverlap; |
| VkBool32 advancedBlendAllOperations; |
| safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& src); |
| safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& src); |
| safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(); |
| ~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* src); |
| VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(this); } |
| VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 srcPremultiplied; |
| VkBool32 dstPremultiplied; |
| VkBlendOverlapEXT blendOverlap; |
| safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct); |
| safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& src); |
| safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& operator=(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& src); |
| safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(); |
| ~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(); |
| void initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* src); |
| VkPipelineColorBlendAdvancedStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(this); } |
| VkPipelineColorBlendAdvancedStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineCoverageToColorStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCoverageToColorStateCreateFlagsNV flags; |
| VkBool32 coverageToColorEnable; |
| uint32_t coverageToColorLocation; |
| safe_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct); |
| safe_VkPipelineCoverageToColorStateCreateInfoNV(const safe_VkPipelineCoverageToColorStateCreateInfoNV& src); |
| safe_VkPipelineCoverageToColorStateCreateInfoNV& operator=(const safe_VkPipelineCoverageToColorStateCreateInfoNV& src); |
| safe_VkPipelineCoverageToColorStateCreateInfoNV(); |
| ~safe_VkPipelineCoverageToColorStateCreateInfoNV(); |
| void initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* src); |
| VkPipelineCoverageToColorStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV *>(this); } |
| VkPipelineCoverageToColorStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkPipelineCoverageModulationStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCoverageModulationStateCreateFlagsNV flags; |
| VkCoverageModulationModeNV coverageModulationMode; |
| VkBool32 coverageModulationTableEnable; |
| uint32_t coverageModulationTableCount; |
| const float* pCoverageModulationTable; |
| safe_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct); |
| safe_VkPipelineCoverageModulationStateCreateInfoNV(const safe_VkPipelineCoverageModulationStateCreateInfoNV& src); |
| safe_VkPipelineCoverageModulationStateCreateInfoNV& operator=(const safe_VkPipelineCoverageModulationStateCreateInfoNV& src); |
| safe_VkPipelineCoverageModulationStateCreateInfoNV(); |
| ~safe_VkPipelineCoverageModulationStateCreateInfoNV(); |
| void initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineCoverageModulationStateCreateInfoNV* src); |
| VkPipelineCoverageModulationStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV *>(this); } |
| VkPipelineCoverageModulationStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t shaderSMCount; |
| uint32_t shaderWarpsPerSM; |
| safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct); |
| safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& src); |
| safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& src); |
| safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(); |
| ~safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(); |
| void initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* src); |
| VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(this); } |
| VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 shaderSMBuiltins; |
| safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& src); |
| safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& src); |
| safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(); |
| ~safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(); |
| void initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* src); |
| VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(this); } |
| VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkDrmFormatModifierPropertiesListEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t drmFormatModifierCount; |
| VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; |
| safe_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* in_struct); |
| safe_VkDrmFormatModifierPropertiesListEXT(const safe_VkDrmFormatModifierPropertiesListEXT& src); |
| safe_VkDrmFormatModifierPropertiesListEXT& operator=(const safe_VkDrmFormatModifierPropertiesListEXT& src); |
| safe_VkDrmFormatModifierPropertiesListEXT(); |
| ~safe_VkDrmFormatModifierPropertiesListEXT(); |
| void initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct); |
| void initialize(const safe_VkDrmFormatModifierPropertiesListEXT* src); |
| VkDrmFormatModifierPropertiesListEXT *ptr() { return reinterpret_cast<VkDrmFormatModifierPropertiesListEXT *>(this); } |
| VkDrmFormatModifierPropertiesListEXT const *ptr() const { return reinterpret_cast<VkDrmFormatModifierPropertiesListEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint64_t drmFormatModifier; |
| VkSharingMode sharingMode; |
| uint32_t queueFamilyIndexCount; |
| const uint32_t* pQueueFamilyIndices; |
| safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct); |
| safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& src); |
| safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& operator=(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& src); |
| safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(); |
| ~safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(); |
| void initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* src); |
| VkPhysicalDeviceImageDrmFormatModifierInfoEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(this); } |
| VkPhysicalDeviceImageDrmFormatModifierInfoEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkImageDrmFormatModifierListCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t drmFormatModifierCount; |
| const uint64_t* pDrmFormatModifiers; |
| safe_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct); |
| safe_VkImageDrmFormatModifierListCreateInfoEXT(const safe_VkImageDrmFormatModifierListCreateInfoEXT& src); |
| safe_VkImageDrmFormatModifierListCreateInfoEXT& operator=(const safe_VkImageDrmFormatModifierListCreateInfoEXT& src); |
| safe_VkImageDrmFormatModifierListCreateInfoEXT(); |
| ~safe_VkImageDrmFormatModifierListCreateInfoEXT(); |
| void initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct); |
| void initialize(const safe_VkImageDrmFormatModifierListCreateInfoEXT* src); |
| VkImageDrmFormatModifierListCreateInfoEXT *ptr() { return reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT *>(this); } |
| VkImageDrmFormatModifierListCreateInfoEXT const *ptr() const { return reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkImageDrmFormatModifierExplicitCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint64_t drmFormatModifier; |
| uint32_t drmFormatModifierPlaneCount; |
| const VkSubresourceLayout* pPlaneLayouts; |
| safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct); |
| safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& src); |
| safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& operator=(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& src); |
| safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(); |
| ~safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(); |
| void initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct); |
| void initialize(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT* src); |
| VkImageDrmFormatModifierExplicitCreateInfoEXT *ptr() { return reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT *>(this); } |
| VkImageDrmFormatModifierExplicitCreateInfoEXT const *ptr() const { return reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkImageDrmFormatModifierPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint64_t drmFormatModifier; |
| safe_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT* in_struct); |
| safe_VkImageDrmFormatModifierPropertiesEXT(const safe_VkImageDrmFormatModifierPropertiesEXT& src); |
| safe_VkImageDrmFormatModifierPropertiesEXT& operator=(const safe_VkImageDrmFormatModifierPropertiesEXT& src); |
| safe_VkImageDrmFormatModifierPropertiesEXT(); |
| ~safe_VkImageDrmFormatModifierPropertiesEXT(); |
| void initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct); |
| void initialize(const safe_VkImageDrmFormatModifierPropertiesEXT* src); |
| VkImageDrmFormatModifierPropertiesEXT *ptr() { return reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>(this); } |
| VkImageDrmFormatModifierPropertiesEXT const *ptr() const { return reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkValidationCacheCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkValidationCacheCreateFlagsEXT flags; |
| size_t initialDataSize; |
| const void* pInitialData; |
| safe_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct); |
| safe_VkValidationCacheCreateInfoEXT(const safe_VkValidationCacheCreateInfoEXT& src); |
| safe_VkValidationCacheCreateInfoEXT& operator=(const safe_VkValidationCacheCreateInfoEXT& src); |
| safe_VkValidationCacheCreateInfoEXT(); |
| ~safe_VkValidationCacheCreateInfoEXT(); |
| void initialize(const VkValidationCacheCreateInfoEXT* in_struct); |
| void initialize(const safe_VkValidationCacheCreateInfoEXT* src); |
| VkValidationCacheCreateInfoEXT *ptr() { return reinterpret_cast<VkValidationCacheCreateInfoEXT *>(this); } |
| VkValidationCacheCreateInfoEXT const *ptr() const { return reinterpret_cast<VkValidationCacheCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkShaderModuleValidationCacheCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkValidationCacheEXT validationCache; |
| safe_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct); |
| safe_VkShaderModuleValidationCacheCreateInfoEXT(const safe_VkShaderModuleValidationCacheCreateInfoEXT& src); |
| safe_VkShaderModuleValidationCacheCreateInfoEXT& operator=(const safe_VkShaderModuleValidationCacheCreateInfoEXT& src); |
| safe_VkShaderModuleValidationCacheCreateInfoEXT(); |
| ~safe_VkShaderModuleValidationCacheCreateInfoEXT(); |
| void initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct); |
| void initialize(const safe_VkShaderModuleValidationCacheCreateInfoEXT* src); |
| VkShaderModuleValidationCacheCreateInfoEXT *ptr() { return reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT *>(this); } |
| VkShaderModuleValidationCacheCreateInfoEXT const *ptr() const { return reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t bindingCount; |
| const VkDescriptorBindingFlagsEXT* pBindingFlags; |
| safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* in_struct); |
| safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT& src); |
| safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT& src); |
| safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(); |
| ~safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(); |
| void initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* in_struct); |
| void initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* src); |
| VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *>(this); } |
| VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 shaderInputAttachmentArrayDynamicIndexing; |
| VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; |
| VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; |
| VkBool32 shaderUniformBufferArrayNonUniformIndexing; |
| VkBool32 shaderSampledImageArrayNonUniformIndexing; |
| VkBool32 shaderStorageBufferArrayNonUniformIndexing; |
| VkBool32 shaderStorageImageArrayNonUniformIndexing; |
| VkBool32 shaderInputAttachmentArrayNonUniformIndexing; |
| VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; |
| VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; |
| VkBool32 descriptorBindingUniformBufferUpdateAfterBind; |
| VkBool32 descriptorBindingSampledImageUpdateAfterBind; |
| VkBool32 descriptorBindingStorageImageUpdateAfterBind; |
| VkBool32 descriptorBindingStorageBufferUpdateAfterBind; |
| VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; |
| VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; |
| VkBool32 descriptorBindingUpdateUnusedWhilePending; |
| VkBool32 descriptorBindingPartiallyBound; |
| VkBool32 descriptorBindingVariableDescriptorCount; |
| VkBool32 runtimeDescriptorArray; |
| safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(const safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT& src); |
| safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT& operator=(const safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT& src); |
| safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(); |
| ~safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT* src); |
| VkPhysicalDeviceDescriptorIndexingFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT *>(this); } |
| VkPhysicalDeviceDescriptorIndexingFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t maxUpdateAfterBindDescriptorsInAllPools; |
| VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; |
| VkBool32 shaderSampledImageArrayNonUniformIndexingNative; |
| VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; |
| VkBool32 shaderStorageImageArrayNonUniformIndexingNative; |
| VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; |
| VkBool32 robustBufferAccessUpdateAfterBind; |
| VkBool32 quadDivergentImplicitLod; |
| uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; |
| uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; |
| uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; |
| uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; |
| uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; |
| uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; |
| uint32_t maxPerStageUpdateAfterBindResources; |
| uint32_t maxDescriptorSetUpdateAfterBindSamplers; |
| uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; |
| uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; |
| uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; |
| uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; |
| uint32_t maxDescriptorSetUpdateAfterBindSampledImages; |
| uint32_t maxDescriptorSetUpdateAfterBindStorageImages; |
| uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; |
| safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(const safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT& src); |
| safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT& operator=(const safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT& src); |
| safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(); |
| ~safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT* src); |
| VkPhysicalDeviceDescriptorIndexingPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT *>(this); } |
| VkPhysicalDeviceDescriptorIndexingPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t descriptorSetCount; |
| const uint32_t* pDescriptorCounts; |
| safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* in_struct); |
| safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT& src); |
| safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT& src); |
| safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(); |
| ~safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(); |
| void initialize(const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* in_struct); |
| void initialize(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* src); |
| VkDescriptorSetVariableDescriptorCountAllocateInfoEXT *ptr() { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT *>(this); } |
| VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const *ptr() const { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t maxVariableDescriptorCount; |
| safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* in_struct); |
| safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT& src); |
| safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT& src); |
| safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(); |
| ~safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(); |
| void initialize(const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* in_struct); |
| void initialize(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* src); |
| VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *ptr() { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *>(this); } |
| VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const *ptr() const { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const *>(this); } |
| }; |
| |
| struct safe_VkShadingRatePaletteNV { |
| uint32_t shadingRatePaletteEntryCount; |
| const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; |
| safe_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct); |
| safe_VkShadingRatePaletteNV(const safe_VkShadingRatePaletteNV& src); |
| safe_VkShadingRatePaletteNV& operator=(const safe_VkShadingRatePaletteNV& src); |
| safe_VkShadingRatePaletteNV(); |
| ~safe_VkShadingRatePaletteNV(); |
| void initialize(const VkShadingRatePaletteNV* in_struct); |
| void initialize(const safe_VkShadingRatePaletteNV* src); |
| VkShadingRatePaletteNV *ptr() { return reinterpret_cast<VkShadingRatePaletteNV *>(this); } |
| VkShadingRatePaletteNV const *ptr() const { return reinterpret_cast<VkShadingRatePaletteNV const *>(this); } |
| }; |
| |
| struct safe_VkPipelineViewportShadingRateImageStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 shadingRateImageEnable; |
| uint32_t viewportCount; |
| safe_VkShadingRatePaletteNV* pShadingRatePalettes; |
| safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct); |
| safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& src); |
| safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& operator=(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& src); |
| safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(); |
| ~safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(); |
| void initialize(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV* src); |
| VkPipelineViewportShadingRateImageStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV *>(this); } |
| VkPipelineViewportShadingRateImageStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShadingRateImageFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 shadingRateImage; |
| VkBool32 shadingRateCoarseSampleOrder; |
| safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& src); |
| safe_VkPhysicalDeviceShadingRateImageFeaturesNV& operator=(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& src); |
| safe_VkPhysicalDeviceShadingRateImageFeaturesNV(); |
| ~safe_VkPhysicalDeviceShadingRateImageFeaturesNV(); |
| void initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV* src); |
| VkPhysicalDeviceShadingRateImageFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV *>(this); } |
| VkPhysicalDeviceShadingRateImageFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShadingRateImagePropertiesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkExtent2D shadingRateTexelSize; |
| uint32_t shadingRatePaletteSize; |
| uint32_t shadingRateMaxCoarseSamples; |
| safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct); |
| safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& src); |
| safe_VkPhysicalDeviceShadingRateImagePropertiesNV& operator=(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& src); |
| safe_VkPhysicalDeviceShadingRateImagePropertiesNV(); |
| ~safe_VkPhysicalDeviceShadingRateImagePropertiesNV(); |
| void initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV* src); |
| VkPhysicalDeviceShadingRateImagePropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV *>(this); } |
| VkPhysicalDeviceShadingRateImagePropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV const *>(this); } |
| }; |
| |
| struct safe_VkCoarseSampleOrderCustomNV { |
| VkShadingRatePaletteEntryNV shadingRate; |
| uint32_t sampleCount; |
| uint32_t sampleLocationCount; |
| const VkCoarseSampleLocationNV* pSampleLocations; |
| safe_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct); |
| safe_VkCoarseSampleOrderCustomNV(const safe_VkCoarseSampleOrderCustomNV& src); |
| safe_VkCoarseSampleOrderCustomNV& operator=(const safe_VkCoarseSampleOrderCustomNV& src); |
| safe_VkCoarseSampleOrderCustomNV(); |
| ~safe_VkCoarseSampleOrderCustomNV(); |
| void initialize(const VkCoarseSampleOrderCustomNV* in_struct); |
| void initialize(const safe_VkCoarseSampleOrderCustomNV* src); |
| VkCoarseSampleOrderCustomNV *ptr() { return reinterpret_cast<VkCoarseSampleOrderCustomNV *>(this); } |
| VkCoarseSampleOrderCustomNV const *ptr() const { return reinterpret_cast<VkCoarseSampleOrderCustomNV const *>(this); } |
| }; |
| |
| struct safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkCoarseSampleOrderTypeNV sampleOrderType; |
| uint32_t customSampleOrderCount; |
| safe_VkCoarseSampleOrderCustomNV* pCustomSampleOrders; |
| safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct); |
| safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& src); |
| safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& src); |
| safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(); |
| ~safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(); |
| void initialize(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* src); |
| VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(this); } |
| VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkRayTracingShaderGroupCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkRayTracingShaderGroupTypeNV type; |
| uint32_t generalShader; |
| uint32_t closestHitShader; |
| uint32_t anyHitShader; |
| uint32_t intersectionShader; |
| safe_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV* in_struct); |
| safe_VkRayTracingShaderGroupCreateInfoNV(const safe_VkRayTracingShaderGroupCreateInfoNV& src); |
| safe_VkRayTracingShaderGroupCreateInfoNV& operator=(const safe_VkRayTracingShaderGroupCreateInfoNV& src); |
| safe_VkRayTracingShaderGroupCreateInfoNV(); |
| ~safe_VkRayTracingShaderGroupCreateInfoNV(); |
| void initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct); |
| void initialize(const safe_VkRayTracingShaderGroupCreateInfoNV* src); |
| VkRayTracingShaderGroupCreateInfoNV *ptr() { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV *>(this); } |
| VkRayTracingShaderGroupCreateInfoNV const *ptr() const { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkRayTracingPipelineCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCreateFlags flags; |
| uint32_t stageCount; |
| safe_VkPipelineShaderStageCreateInfo* pStages; |
| uint32_t groupCount; |
| safe_VkRayTracingShaderGroupCreateInfoNV* pGroups; |
| uint32_t maxRecursionDepth; |
| VkPipelineLayout layout; |
| VkPipeline basePipelineHandle; |
| int32_t basePipelineIndex; |
| safe_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct); |
| safe_VkRayTracingPipelineCreateInfoNV(const safe_VkRayTracingPipelineCreateInfoNV& src); |
| safe_VkRayTracingPipelineCreateInfoNV& operator=(const safe_VkRayTracingPipelineCreateInfoNV& src); |
| safe_VkRayTracingPipelineCreateInfoNV(); |
| ~safe_VkRayTracingPipelineCreateInfoNV(); |
| void initialize(const VkRayTracingPipelineCreateInfoNV* in_struct); |
| void initialize(const safe_VkRayTracingPipelineCreateInfoNV* src); |
| VkRayTracingPipelineCreateInfoNV *ptr() { return reinterpret_cast<VkRayTracingPipelineCreateInfoNV *>(this); } |
| VkRayTracingPipelineCreateInfoNV const *ptr() const { return reinterpret_cast<VkRayTracingPipelineCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkGeometryTrianglesNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkBuffer vertexData; |
| VkDeviceSize vertexOffset; |
| uint32_t vertexCount; |
| VkDeviceSize vertexStride; |
| VkFormat vertexFormat; |
| VkBuffer indexData; |
| VkDeviceSize indexOffset; |
| uint32_t indexCount; |
| VkIndexType indexType; |
| VkBuffer transformData; |
| VkDeviceSize transformOffset; |
| safe_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct); |
| safe_VkGeometryTrianglesNV(const safe_VkGeometryTrianglesNV& src); |
| safe_VkGeometryTrianglesNV& operator=(const safe_VkGeometryTrianglesNV& src); |
| safe_VkGeometryTrianglesNV(); |
| ~safe_VkGeometryTrianglesNV(); |
| void initialize(const VkGeometryTrianglesNV* in_struct); |
| void initialize(const safe_VkGeometryTrianglesNV* src); |
| VkGeometryTrianglesNV *ptr() { return reinterpret_cast<VkGeometryTrianglesNV *>(this); } |
| VkGeometryTrianglesNV const *ptr() const { return reinterpret_cast<VkGeometryTrianglesNV const *>(this); } |
| }; |
| |
| struct safe_VkGeometryAABBNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkBuffer aabbData; |
| uint32_t numAABBs; |
| uint32_t stride; |
| VkDeviceSize offset; |
| safe_VkGeometryAABBNV(const VkGeometryAABBNV* in_struct); |
| safe_VkGeometryAABBNV(const safe_VkGeometryAABBNV& src); |
| safe_VkGeometryAABBNV& operator=(const safe_VkGeometryAABBNV& src); |
| safe_VkGeometryAABBNV(); |
| ~safe_VkGeometryAABBNV(); |
| void initialize(const VkGeometryAABBNV* in_struct); |
| void initialize(const safe_VkGeometryAABBNV* src); |
| VkGeometryAABBNV *ptr() { return reinterpret_cast<VkGeometryAABBNV *>(this); } |
| VkGeometryAABBNV const *ptr() const { return reinterpret_cast<VkGeometryAABBNV const *>(this); } |
| }; |
| |
| struct safe_VkGeometryNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkGeometryTypeNV geometryType; |
| VkGeometryDataNV geometry; |
| VkGeometryFlagsNV flags; |
| safe_VkGeometryNV(const VkGeometryNV* in_struct); |
| safe_VkGeometryNV(const safe_VkGeometryNV& src); |
| safe_VkGeometryNV& operator=(const safe_VkGeometryNV& src); |
| safe_VkGeometryNV(); |
| ~safe_VkGeometryNV(); |
| void initialize(const VkGeometryNV* in_struct); |
| void initialize(const safe_VkGeometryNV* src); |
| VkGeometryNV *ptr() { return reinterpret_cast<VkGeometryNV *>(this); } |
| VkGeometryNV const *ptr() const { return reinterpret_cast<VkGeometryNV const *>(this); } |
| }; |
| |
| struct safe_VkAccelerationStructureInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkAccelerationStructureTypeNV type; |
| VkBuildAccelerationStructureFlagsNV flags; |
| uint32_t instanceCount; |
| uint32_t geometryCount; |
| safe_VkGeometryNV* pGeometries; |
| safe_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct); |
| safe_VkAccelerationStructureInfoNV(const safe_VkAccelerationStructureInfoNV& src); |
| safe_VkAccelerationStructureInfoNV& operator=(const safe_VkAccelerationStructureInfoNV& src); |
| safe_VkAccelerationStructureInfoNV(); |
| ~safe_VkAccelerationStructureInfoNV(); |
| void initialize(const VkAccelerationStructureInfoNV* in_struct); |
| void initialize(const safe_VkAccelerationStructureInfoNV* src); |
| VkAccelerationStructureInfoNV *ptr() { return reinterpret_cast<VkAccelerationStructureInfoNV *>(this); } |
| VkAccelerationStructureInfoNV const *ptr() const { return reinterpret_cast<VkAccelerationStructureInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkAccelerationStructureCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceSize compactedSize; |
| safe_VkAccelerationStructureInfoNV info; |
| safe_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV* in_struct); |
| safe_VkAccelerationStructureCreateInfoNV(const safe_VkAccelerationStructureCreateInfoNV& src); |
| safe_VkAccelerationStructureCreateInfoNV& operator=(const safe_VkAccelerationStructureCreateInfoNV& src); |
| safe_VkAccelerationStructureCreateInfoNV(); |
| ~safe_VkAccelerationStructureCreateInfoNV(); |
| void initialize(const VkAccelerationStructureCreateInfoNV* in_struct); |
| void initialize(const safe_VkAccelerationStructureCreateInfoNV* src); |
| VkAccelerationStructureCreateInfoNV *ptr() { return reinterpret_cast<VkAccelerationStructureCreateInfoNV *>(this); } |
| VkAccelerationStructureCreateInfoNV const *ptr() const { return reinterpret_cast<VkAccelerationStructureCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkBindAccelerationStructureMemoryInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkAccelerationStructureNV accelerationStructure; |
| VkDeviceMemory memory; |
| VkDeviceSize memoryOffset; |
| uint32_t deviceIndexCount; |
| const uint32_t* pDeviceIndices; |
| safe_VkBindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV* in_struct); |
| safe_VkBindAccelerationStructureMemoryInfoNV(const safe_VkBindAccelerationStructureMemoryInfoNV& src); |
| safe_VkBindAccelerationStructureMemoryInfoNV& operator=(const safe_VkBindAccelerationStructureMemoryInfoNV& src); |
| safe_VkBindAccelerationStructureMemoryInfoNV(); |
| ~safe_VkBindAccelerationStructureMemoryInfoNV(); |
| void initialize(const VkBindAccelerationStructureMemoryInfoNV* in_struct); |
| void initialize(const safe_VkBindAccelerationStructureMemoryInfoNV* src); |
| VkBindAccelerationStructureMemoryInfoNV *ptr() { return reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV *>(this); } |
| VkBindAccelerationStructureMemoryInfoNV const *ptr() const { return reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkWriteDescriptorSetAccelerationStructureNV { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t accelerationStructureCount; |
| VkAccelerationStructureNV* pAccelerationStructures; |
| safe_VkWriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV* in_struct); |
| safe_VkWriteDescriptorSetAccelerationStructureNV(const safe_VkWriteDescriptorSetAccelerationStructureNV& src); |
| safe_VkWriteDescriptorSetAccelerationStructureNV& operator=(const safe_VkWriteDescriptorSetAccelerationStructureNV& src); |
| safe_VkWriteDescriptorSetAccelerationStructureNV(); |
| ~safe_VkWriteDescriptorSetAccelerationStructureNV(); |
| void initialize(const VkWriteDescriptorSetAccelerationStructureNV* in_struct); |
| void initialize(const safe_VkWriteDescriptorSetAccelerationStructureNV* src); |
| VkWriteDescriptorSetAccelerationStructureNV *ptr() { return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV *>(this); } |
| VkWriteDescriptorSetAccelerationStructureNV const *ptr() const { return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV const *>(this); } |
| }; |
| |
| struct safe_VkAccelerationStructureMemoryRequirementsInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkAccelerationStructureMemoryRequirementsTypeNV type; |
| VkAccelerationStructureNV accelerationStructure; |
| safe_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct); |
| safe_VkAccelerationStructureMemoryRequirementsInfoNV(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& src); |
| safe_VkAccelerationStructureMemoryRequirementsInfoNV& operator=(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& src); |
| safe_VkAccelerationStructureMemoryRequirementsInfoNV(); |
| ~safe_VkAccelerationStructureMemoryRequirementsInfoNV(); |
| void initialize(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct); |
| void initialize(const safe_VkAccelerationStructureMemoryRequirementsInfoNV* src); |
| VkAccelerationStructureMemoryRequirementsInfoNV *ptr() { return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV *>(this); } |
| VkAccelerationStructureMemoryRequirementsInfoNV const *ptr() const { return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceRayTracingPropertiesNV { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t shaderGroupHandleSize; |
| uint32_t maxRecursionDepth; |
| uint32_t maxShaderGroupStride; |
| uint32_t shaderGroupBaseAlignment; |
| uint64_t maxGeometryCount; |
| uint64_t maxInstanceCount; |
| uint64_t maxTriangleCount; |
| uint32_t maxDescriptorSetAccelerationStructures; |
| safe_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct); |
| safe_VkPhysicalDeviceRayTracingPropertiesNV(const safe_VkPhysicalDeviceRayTracingPropertiesNV& src); |
| safe_VkPhysicalDeviceRayTracingPropertiesNV& operator=(const safe_VkPhysicalDeviceRayTracingPropertiesNV& src); |
| safe_VkPhysicalDeviceRayTracingPropertiesNV(); |
| ~safe_VkPhysicalDeviceRayTracingPropertiesNV(); |
| void initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceRayTracingPropertiesNV* src); |
| VkPhysicalDeviceRayTracingPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV *>(this); } |
| VkPhysicalDeviceRayTracingPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 representativeFragmentTest; |
| safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& src); |
| safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& src); |
| safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(); |
| ~safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(); |
| void initialize(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* src); |
| VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(this); } |
| VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 representativeFragmentTestEnable; |
| safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct); |
| safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& src); |
| safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& operator=(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& src); |
| safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(); |
| ~safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(); |
| void initialize(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* src); |
| VkPipelineRepresentativeFragmentTestStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(this); } |
| VkPipelineRepresentativeFragmentTestStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceImageViewImageFormatInfoEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkImageViewType imageViewType; |
| safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct); |
| safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& src); |
| safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& operator=(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& src); |
| safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(); |
| ~safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(); |
| void initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT* src); |
| VkPhysicalDeviceImageViewImageFormatInfoEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT *>(this); } |
| VkPhysicalDeviceImageViewImageFormatInfoEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkFilterCubicImageViewImageFormatPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 filterCubic; |
| VkBool32 filterCubicMinmax ; |
| safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct); |
| safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& src); |
| safe_VkFilterCubicImageViewImageFormatPropertiesEXT& operator=(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& src); |
| safe_VkFilterCubicImageViewImageFormatPropertiesEXT(); |
| ~safe_VkFilterCubicImageViewImageFormatPropertiesEXT(); |
| void initialize(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct); |
| void initialize(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT* src); |
| VkFilterCubicImageViewImageFormatPropertiesEXT *ptr() { return reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT *>(this); } |
| VkFilterCubicImageViewImageFormatPropertiesEXT const *ptr() const { return reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkDeviceQueueGlobalPriorityCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkQueueGlobalPriorityEXT globalPriority; |
| safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT* in_struct); |
| safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& src); |
| safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& src); |
| safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(); |
| ~safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(); |
| void initialize(const VkDeviceQueueGlobalPriorityCreateInfoEXT* in_struct); |
| void initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT* src); |
| VkDeviceQueueGlobalPriorityCreateInfoEXT *ptr() { return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT *>(this); } |
| VkDeviceQueueGlobalPriorityCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkImportMemoryHostPointerInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkExternalMemoryHandleTypeFlagBits handleType; |
| void* pHostPointer; |
| safe_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct); |
| safe_VkImportMemoryHostPointerInfoEXT(const safe_VkImportMemoryHostPointerInfoEXT& src); |
| safe_VkImportMemoryHostPointerInfoEXT& operator=(const safe_VkImportMemoryHostPointerInfoEXT& src); |
| safe_VkImportMemoryHostPointerInfoEXT(); |
| ~safe_VkImportMemoryHostPointerInfoEXT(); |
| void initialize(const VkImportMemoryHostPointerInfoEXT* in_struct); |
| void initialize(const safe_VkImportMemoryHostPointerInfoEXT* src); |
| VkImportMemoryHostPointerInfoEXT *ptr() { return reinterpret_cast<VkImportMemoryHostPointerInfoEXT *>(this); } |
| VkImportMemoryHostPointerInfoEXT const *ptr() const { return reinterpret_cast<VkImportMemoryHostPointerInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkMemoryHostPointerPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t memoryTypeBits; |
| safe_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* in_struct); |
| safe_VkMemoryHostPointerPropertiesEXT(const safe_VkMemoryHostPointerPropertiesEXT& src); |
| safe_VkMemoryHostPointerPropertiesEXT& operator=(const safe_VkMemoryHostPointerPropertiesEXT& src); |
| safe_VkMemoryHostPointerPropertiesEXT(); |
| ~safe_VkMemoryHostPointerPropertiesEXT(); |
| void initialize(const VkMemoryHostPointerPropertiesEXT* in_struct); |
| void initialize(const safe_VkMemoryHostPointerPropertiesEXT* src); |
| VkMemoryHostPointerPropertiesEXT *ptr() { return reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>(this); } |
| VkMemoryHostPointerPropertiesEXT const *ptr() const { return reinterpret_cast<VkMemoryHostPointerPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkDeviceSize minImportedHostPointerAlignment; |
| safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& src); |
| safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& operator=(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& src); |
| safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(); |
| ~safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* src); |
| VkPhysicalDeviceExternalMemoryHostPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(this); } |
| VkPhysicalDeviceExternalMemoryHostPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineCompilerControlCreateInfoAMD { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCompilerControlFlagsAMD compilerControlFlags; |
| safe_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD* in_struct); |
| safe_VkPipelineCompilerControlCreateInfoAMD(const safe_VkPipelineCompilerControlCreateInfoAMD& src); |
| safe_VkPipelineCompilerControlCreateInfoAMD& operator=(const safe_VkPipelineCompilerControlCreateInfoAMD& src); |
| safe_VkPipelineCompilerControlCreateInfoAMD(); |
| ~safe_VkPipelineCompilerControlCreateInfoAMD(); |
| void initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct); |
| void initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* src); |
| VkPipelineCompilerControlCreateInfoAMD *ptr() { return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD *>(this); } |
| VkPipelineCompilerControlCreateInfoAMD const *ptr() const { return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD const *>(this); } |
| }; |
| |
| struct safe_VkCalibratedTimestampInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkTimeDomainEXT timeDomain; |
| safe_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT* in_struct); |
| safe_VkCalibratedTimestampInfoEXT(const safe_VkCalibratedTimestampInfoEXT& src); |
| safe_VkCalibratedTimestampInfoEXT& operator=(const safe_VkCalibratedTimestampInfoEXT& src); |
| safe_VkCalibratedTimestampInfoEXT(); |
| ~safe_VkCalibratedTimestampInfoEXT(); |
| void initialize(const VkCalibratedTimestampInfoEXT* in_struct); |
| void initialize(const safe_VkCalibratedTimestampInfoEXT* src); |
| VkCalibratedTimestampInfoEXT *ptr() { return reinterpret_cast<VkCalibratedTimestampInfoEXT *>(this); } |
| VkCalibratedTimestampInfoEXT const *ptr() const { return reinterpret_cast<VkCalibratedTimestampInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderCorePropertiesAMD { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t shaderEngineCount; |
| uint32_t shaderArraysPerEngineCount; |
| uint32_t computeUnitsPerShaderArray; |
| uint32_t simdPerComputeUnit; |
| uint32_t wavefrontsPerSimd; |
| uint32_t wavefrontSize; |
| uint32_t sgprsPerSimd; |
| uint32_t minSgprAllocation; |
| uint32_t maxSgprAllocation; |
| uint32_t sgprAllocationGranularity; |
| uint32_t vgprsPerSimd; |
| uint32_t minVgprAllocation; |
| uint32_t maxVgprAllocation; |
| uint32_t vgprAllocationGranularity; |
| safe_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct); |
| safe_VkPhysicalDeviceShaderCorePropertiesAMD(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& src); |
| safe_VkPhysicalDeviceShaderCorePropertiesAMD& operator=(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& src); |
| safe_VkPhysicalDeviceShaderCorePropertiesAMD(); |
| ~safe_VkPhysicalDeviceShaderCorePropertiesAMD(); |
| void initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderCorePropertiesAMD* src); |
| VkPhysicalDeviceShaderCorePropertiesAMD *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD *>(this); } |
| VkPhysicalDeviceShaderCorePropertiesAMD const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD const *>(this); } |
| }; |
| |
| struct safe_VkDeviceMemoryOverallocationCreateInfoAMD { |
| VkStructureType sType; |
| const void* pNext; |
| VkMemoryOverallocationBehaviorAMD overallocationBehavior; |
| safe_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct); |
| safe_VkDeviceMemoryOverallocationCreateInfoAMD(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& src); |
| safe_VkDeviceMemoryOverallocationCreateInfoAMD& operator=(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& src); |
| safe_VkDeviceMemoryOverallocationCreateInfoAMD(); |
| ~safe_VkDeviceMemoryOverallocationCreateInfoAMD(); |
| void initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct); |
| void initialize(const safe_VkDeviceMemoryOverallocationCreateInfoAMD* src); |
| VkDeviceMemoryOverallocationCreateInfoAMD *ptr() { return reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD *>(this); } |
| VkDeviceMemoryOverallocationCreateInfoAMD const *ptr() const { return reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t maxVertexAttribDivisor; |
| safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& src); |
| safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& src); |
| safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(); |
| ~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* src); |
| VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(this); } |
| VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineVertexInputDivisorStateCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t vertexBindingDivisorCount; |
| const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; |
| safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT* in_struct); |
| safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& src); |
| safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& operator=(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& src); |
| safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(); |
| ~safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(); |
| void initialize(const VkPipelineVertexInputDivisorStateCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT* src); |
| VkPipelineVertexInputDivisorStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT *>(this); } |
| VkPipelineVertexInputDivisorStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 vertexAttributeInstanceRateDivisor; |
| VkBool32 vertexAttributeInstanceRateZeroDivisor; |
| safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& src); |
| safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& src); |
| safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(); |
| ~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* src); |
| VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>(this); } |
| VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_GGP |
| struct safe_VkPresentFrameTokenGGP { |
| VkStructureType sType; |
| const void* pNext; |
| GgpFrameToken frameToken; |
| safe_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct); |
| safe_VkPresentFrameTokenGGP(const safe_VkPresentFrameTokenGGP& src); |
| safe_VkPresentFrameTokenGGP& operator=(const safe_VkPresentFrameTokenGGP& src); |
| safe_VkPresentFrameTokenGGP(); |
| ~safe_VkPresentFrameTokenGGP(); |
| void initialize(const VkPresentFrameTokenGGP* in_struct); |
| void initialize(const safe_VkPresentFrameTokenGGP* src); |
| VkPresentFrameTokenGGP *ptr() { return reinterpret_cast<VkPresentFrameTokenGGP *>(this); } |
| VkPresentFrameTokenGGP const *ptr() const { return reinterpret_cast<VkPresentFrameTokenGGP const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_GGP |
| |
| struct safe_VkPipelineCreationFeedbackCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCreationFeedbackEXT* pPipelineCreationFeedback; |
| uint32_t pipelineStageCreationFeedbackCount; |
| VkPipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks; |
| safe_VkPipelineCreationFeedbackCreateInfoEXT(const VkPipelineCreationFeedbackCreateInfoEXT* in_struct); |
| safe_VkPipelineCreationFeedbackCreateInfoEXT(const safe_VkPipelineCreationFeedbackCreateInfoEXT& src); |
| safe_VkPipelineCreationFeedbackCreateInfoEXT& operator=(const safe_VkPipelineCreationFeedbackCreateInfoEXT& src); |
| safe_VkPipelineCreationFeedbackCreateInfoEXT(); |
| ~safe_VkPipelineCreationFeedbackCreateInfoEXT(); |
| void initialize(const VkPipelineCreationFeedbackCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineCreationFeedbackCreateInfoEXT* src); |
| VkPipelineCreationFeedbackCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT *>(this); } |
| VkPipelineCreationFeedbackCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 computeDerivativeGroupQuads; |
| VkBool32 computeDerivativeGroupLinear; |
| safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& src); |
| safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& src); |
| safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(); |
| ~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(); |
| void initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* src); |
| VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(this); } |
| VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceMeshShaderFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 taskShader; |
| VkBool32 meshShader; |
| safe_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceMeshShaderFeaturesNV(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& src); |
| safe_VkPhysicalDeviceMeshShaderFeaturesNV& operator=(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& src); |
| safe_VkPhysicalDeviceMeshShaderFeaturesNV(); |
| ~safe_VkPhysicalDeviceMeshShaderFeaturesNV(); |
| void initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesNV* src); |
| VkPhysicalDeviceMeshShaderFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV *>(this); } |
| VkPhysicalDeviceMeshShaderFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceMeshShaderPropertiesNV { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t maxDrawMeshTasksCount; |
| uint32_t maxTaskWorkGroupInvocations; |
| uint32_t maxTaskWorkGroupSize[3]; |
| uint32_t maxTaskTotalMemorySize; |
| uint32_t maxTaskOutputCount; |
| uint32_t maxMeshWorkGroupInvocations; |
| uint32_t maxMeshWorkGroupSize[3]; |
| uint32_t maxMeshTotalMemorySize; |
| uint32_t maxMeshOutputVertices; |
| uint32_t maxMeshOutputPrimitives; |
| uint32_t maxMeshMultiviewViewCount; |
| uint32_t meshOutputPerVertexGranularity; |
| uint32_t meshOutputPerPrimitiveGranularity; |
| safe_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct); |
| safe_VkPhysicalDeviceMeshShaderPropertiesNV(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& src); |
| safe_VkPhysicalDeviceMeshShaderPropertiesNV& operator=(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& src); |
| safe_VkPhysicalDeviceMeshShaderPropertiesNV(); |
| ~safe_VkPhysicalDeviceMeshShaderPropertiesNV(); |
| void initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesNV* src); |
| VkPhysicalDeviceMeshShaderPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV *>(this); } |
| VkPhysicalDeviceMeshShaderPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 fragmentShaderBarycentric; |
| safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& src); |
| safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& src); |
| safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(); |
| ~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(); |
| void initialize(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* src); |
| VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>(this); } |
| VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 imageFootprint; |
| safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& src); |
| safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& operator=(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& src); |
| safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(); |
| ~safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(); |
| void initialize(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV* src); |
| VkPhysicalDeviceShaderImageFootprintFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(this); } |
| VkPhysicalDeviceShaderImageFootprintFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t exclusiveScissorCount; |
| const VkRect2D* pExclusiveScissors; |
| safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct); |
| safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& src); |
| safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& operator=(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& src); |
| safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(); |
| ~safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(); |
| void initialize(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV* src); |
| VkPipelineViewportExclusiveScissorStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(this); } |
| VkPipelineViewportExclusiveScissorStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceExclusiveScissorFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 exclusiveScissor; |
| safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& src); |
| safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& operator=(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& src); |
| safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(); |
| ~safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(); |
| void initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV* src); |
| VkPhysicalDeviceExclusiveScissorFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV *>(this); } |
| VkPhysicalDeviceExclusiveScissorFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkQueueFamilyCheckpointPropertiesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkPipelineStageFlags checkpointExecutionStageMask; |
| safe_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV* in_struct); |
| safe_VkQueueFamilyCheckpointPropertiesNV(const safe_VkQueueFamilyCheckpointPropertiesNV& src); |
| safe_VkQueueFamilyCheckpointPropertiesNV& operator=(const safe_VkQueueFamilyCheckpointPropertiesNV& src); |
| safe_VkQueueFamilyCheckpointPropertiesNV(); |
| ~safe_VkQueueFamilyCheckpointPropertiesNV(); |
| void initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct); |
| void initialize(const safe_VkQueueFamilyCheckpointPropertiesNV* src); |
| VkQueueFamilyCheckpointPropertiesNV *ptr() { return reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV *>(this); } |
| VkQueueFamilyCheckpointPropertiesNV const *ptr() const { return reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV const *>(this); } |
| }; |
| |
| struct safe_VkCheckpointDataNV { |
| VkStructureType sType; |
| void* pNext; |
| VkPipelineStageFlagBits stage; |
| void* pCheckpointMarker; |
| safe_VkCheckpointDataNV(const VkCheckpointDataNV* in_struct); |
| safe_VkCheckpointDataNV(const safe_VkCheckpointDataNV& src); |
| safe_VkCheckpointDataNV& operator=(const safe_VkCheckpointDataNV& src); |
| safe_VkCheckpointDataNV(); |
| ~safe_VkCheckpointDataNV(); |
| void initialize(const VkCheckpointDataNV* in_struct); |
| void initialize(const safe_VkCheckpointDataNV* src); |
| VkCheckpointDataNV *ptr() { return reinterpret_cast<VkCheckpointDataNV *>(this); } |
| VkCheckpointDataNV const *ptr() const { return reinterpret_cast<VkCheckpointDataNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 shaderIntegerFunctions2; |
| safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct); |
| safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& src); |
| safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& src); |
| safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(); |
| ~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(); |
| void initialize(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* src); |
| VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(this); } |
| VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *>(this); } |
| }; |
| |
| struct safe_VkPerformanceValueDataINTEL { |
| uint32_t value32; |
| uint64_t value64; |
| float valueFloat; |
| VkBool32 valueBool; |
| const char* valueString; |
| safe_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct); |
| safe_VkPerformanceValueDataINTEL(const safe_VkPerformanceValueDataINTEL& src); |
| safe_VkPerformanceValueDataINTEL& operator=(const safe_VkPerformanceValueDataINTEL& src); |
| safe_VkPerformanceValueDataINTEL(); |
| ~safe_VkPerformanceValueDataINTEL(); |
| void initialize(const VkPerformanceValueDataINTEL* in_struct); |
| void initialize(const safe_VkPerformanceValueDataINTEL* src); |
| VkPerformanceValueDataINTEL *ptr() { return reinterpret_cast<VkPerformanceValueDataINTEL *>(this); } |
| VkPerformanceValueDataINTEL const *ptr() const { return reinterpret_cast<VkPerformanceValueDataINTEL const *>(this); } |
| }; |
| |
| struct safe_VkInitializePerformanceApiInfoINTEL { |
| VkStructureType sType; |
| const void* pNext; |
| void* pUserData; |
| safe_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL* in_struct); |
| safe_VkInitializePerformanceApiInfoINTEL(const safe_VkInitializePerformanceApiInfoINTEL& src); |
| safe_VkInitializePerformanceApiInfoINTEL& operator=(const safe_VkInitializePerformanceApiInfoINTEL& src); |
| safe_VkInitializePerformanceApiInfoINTEL(); |
| ~safe_VkInitializePerformanceApiInfoINTEL(); |
| void initialize(const VkInitializePerformanceApiInfoINTEL* in_struct); |
| void initialize(const safe_VkInitializePerformanceApiInfoINTEL* src); |
| VkInitializePerformanceApiInfoINTEL *ptr() { return reinterpret_cast<VkInitializePerformanceApiInfoINTEL *>(this); } |
| VkInitializePerformanceApiInfoINTEL const *ptr() const { return reinterpret_cast<VkInitializePerformanceApiInfoINTEL const *>(this); } |
| }; |
| |
| struct safe_VkQueryPoolCreateInfoINTEL { |
| VkStructureType sType; |
| const void* pNext; |
| VkQueryPoolSamplingModeINTEL performanceCountersSampling; |
| safe_VkQueryPoolCreateInfoINTEL(const VkQueryPoolCreateInfoINTEL* in_struct); |
| safe_VkQueryPoolCreateInfoINTEL(const safe_VkQueryPoolCreateInfoINTEL& src); |
| safe_VkQueryPoolCreateInfoINTEL& operator=(const safe_VkQueryPoolCreateInfoINTEL& src); |
| safe_VkQueryPoolCreateInfoINTEL(); |
| ~safe_VkQueryPoolCreateInfoINTEL(); |
| void initialize(const VkQueryPoolCreateInfoINTEL* in_struct); |
| void initialize(const safe_VkQueryPoolCreateInfoINTEL* src); |
| VkQueryPoolCreateInfoINTEL *ptr() { return reinterpret_cast<VkQueryPoolCreateInfoINTEL *>(this); } |
| VkQueryPoolCreateInfoINTEL const *ptr() const { return reinterpret_cast<VkQueryPoolCreateInfoINTEL const *>(this); } |
| }; |
| |
| struct safe_VkPerformanceMarkerInfoINTEL { |
| VkStructureType sType; |
| const void* pNext; |
| uint64_t marker; |
| safe_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct); |
| safe_VkPerformanceMarkerInfoINTEL(const safe_VkPerformanceMarkerInfoINTEL& src); |
| safe_VkPerformanceMarkerInfoINTEL& operator=(const safe_VkPerformanceMarkerInfoINTEL& src); |
| safe_VkPerformanceMarkerInfoINTEL(); |
| ~safe_VkPerformanceMarkerInfoINTEL(); |
| void initialize(const VkPerformanceMarkerInfoINTEL* in_struct); |
| void initialize(const safe_VkPerformanceMarkerInfoINTEL* src); |
| VkPerformanceMarkerInfoINTEL *ptr() { return reinterpret_cast<VkPerformanceMarkerInfoINTEL *>(this); } |
| VkPerformanceMarkerInfoINTEL const *ptr() const { return reinterpret_cast<VkPerformanceMarkerInfoINTEL const *>(this); } |
| }; |
| |
| struct safe_VkPerformanceStreamMarkerInfoINTEL { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t marker; |
| safe_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL* in_struct); |
| safe_VkPerformanceStreamMarkerInfoINTEL(const safe_VkPerformanceStreamMarkerInfoINTEL& src); |
| safe_VkPerformanceStreamMarkerInfoINTEL& operator=(const safe_VkPerformanceStreamMarkerInfoINTEL& src); |
| safe_VkPerformanceStreamMarkerInfoINTEL(); |
| ~safe_VkPerformanceStreamMarkerInfoINTEL(); |
| void initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct); |
| void initialize(const safe_VkPerformanceStreamMarkerInfoINTEL* src); |
| VkPerformanceStreamMarkerInfoINTEL *ptr() { return reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL *>(this); } |
| VkPerformanceStreamMarkerInfoINTEL const *ptr() const { return reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL const *>(this); } |
| }; |
| |
| struct safe_VkPerformanceOverrideInfoINTEL { |
| VkStructureType sType; |
| const void* pNext; |
| VkPerformanceOverrideTypeINTEL type; |
| VkBool32 enable; |
| uint64_t parameter; |
| safe_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct); |
| safe_VkPerformanceOverrideInfoINTEL(const safe_VkPerformanceOverrideInfoINTEL& src); |
| safe_VkPerformanceOverrideInfoINTEL& operator=(const safe_VkPerformanceOverrideInfoINTEL& src); |
| safe_VkPerformanceOverrideInfoINTEL(); |
| ~safe_VkPerformanceOverrideInfoINTEL(); |
| void initialize(const VkPerformanceOverrideInfoINTEL* in_struct); |
| void initialize(const safe_VkPerformanceOverrideInfoINTEL* src); |
| VkPerformanceOverrideInfoINTEL *ptr() { return reinterpret_cast<VkPerformanceOverrideInfoINTEL *>(this); } |
| VkPerformanceOverrideInfoINTEL const *ptr() const { return reinterpret_cast<VkPerformanceOverrideInfoINTEL const *>(this); } |
| }; |
| |
| struct safe_VkPerformanceConfigurationAcquireInfoINTEL { |
| VkStructureType sType; |
| const void* pNext; |
| VkPerformanceConfigurationTypeINTEL type; |
| safe_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct); |
| safe_VkPerformanceConfigurationAcquireInfoINTEL(const safe_VkPerformanceConfigurationAcquireInfoINTEL& src); |
| safe_VkPerformanceConfigurationAcquireInfoINTEL& operator=(const safe_VkPerformanceConfigurationAcquireInfoINTEL& src); |
| safe_VkPerformanceConfigurationAcquireInfoINTEL(); |
| ~safe_VkPerformanceConfigurationAcquireInfoINTEL(); |
| void initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct); |
| void initialize(const safe_VkPerformanceConfigurationAcquireInfoINTEL* src); |
| VkPerformanceConfigurationAcquireInfoINTEL *ptr() { return reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL *>(this); } |
| VkPerformanceConfigurationAcquireInfoINTEL const *ptr() const { return reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDevicePCIBusInfoPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t pciDomain; |
| uint32_t pciBus; |
| uint32_t pciDevice; |
| uint32_t pciFunction; |
| safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct); |
| safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& src); |
| safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& operator=(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& src); |
| safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(); |
| ~safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(); |
| void initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT* src); |
| VkPhysicalDevicePCIBusInfoPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT *>(this); } |
| VkPhysicalDevicePCIBusInfoPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 localDimmingSupport; |
| safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct); |
| safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& src); |
| safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& operator=(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& src); |
| safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(); |
| ~safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(); |
| void initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct); |
| void initialize(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD* src); |
| VkDisplayNativeHdrSurfaceCapabilitiesAMD *ptr() { return reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(this); } |
| VkDisplayNativeHdrSurfaceCapabilitiesAMD const *ptr() const { return reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD const *>(this); } |
| }; |
| |
| struct safe_VkSwapchainDisplayNativeHdrCreateInfoAMD { |
| VkStructureType sType; |
| const void* pNext; |
| VkBool32 localDimmingEnable; |
| safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct); |
| safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& src); |
| safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& operator=(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& src); |
| safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(); |
| ~safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(); |
| void initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct); |
| void initialize(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD* src); |
| VkSwapchainDisplayNativeHdrCreateInfoAMD *ptr() { return reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD *>(this); } |
| VkSwapchainDisplayNativeHdrCreateInfoAMD const *ptr() const { return reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| struct safe_VkImagePipeSurfaceCreateInfoFUCHSIA { |
| VkStructureType sType; |
| const void* pNext; |
| VkImagePipeSurfaceCreateFlagsFUCHSIA flags; |
| zx_handle_t imagePipeHandle; |
| safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct); |
| safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& src); |
| safe_VkImagePipeSurfaceCreateInfoFUCHSIA& operator=(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& src); |
| safe_VkImagePipeSurfaceCreateInfoFUCHSIA(); |
| ~safe_VkImagePipeSurfaceCreateInfoFUCHSIA(); |
| void initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct); |
| void initialize(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA* src); |
| VkImagePipeSurfaceCreateInfoFUCHSIA *ptr() { return reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA *>(this); } |
| VkImagePipeSurfaceCreateInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_METAL_EXT |
| struct safe_VkMetalSurfaceCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkMetalSurfaceCreateFlagsEXT flags; |
| const CAMetalLayer* pLayer; |
| safe_VkMetalSurfaceCreateInfoEXT(const VkMetalSurfaceCreateInfoEXT* in_struct); |
| safe_VkMetalSurfaceCreateInfoEXT(const safe_VkMetalSurfaceCreateInfoEXT& src); |
| safe_VkMetalSurfaceCreateInfoEXT& operator=(const safe_VkMetalSurfaceCreateInfoEXT& src); |
| safe_VkMetalSurfaceCreateInfoEXT(); |
| ~safe_VkMetalSurfaceCreateInfoEXT(); |
| void initialize(const VkMetalSurfaceCreateInfoEXT* in_struct); |
| void initialize(const safe_VkMetalSurfaceCreateInfoEXT* src); |
| VkMetalSurfaceCreateInfoEXT *ptr() { return reinterpret_cast<VkMetalSurfaceCreateInfoEXT *>(this); } |
| VkMetalSurfaceCreateInfoEXT const *ptr() const { return reinterpret_cast<VkMetalSurfaceCreateInfoEXT const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_METAL_EXT |
| |
| struct safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 fragmentDensityMap; |
| VkBool32 fragmentDensityMapDynamic; |
| VkBool32 fragmentDensityMapNonSubsampledImages; |
| safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& src); |
| safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& operator=(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& src); |
| safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(); |
| ~safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* src); |
| VkPhysicalDeviceFragmentDensityMapFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(this); } |
| VkPhysicalDeviceFragmentDensityMapFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkExtent2D minFragmentDensityTexelSize; |
| VkExtent2D maxFragmentDensityTexelSize; |
| VkBool32 fragmentDensityInvocations; |
| safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& src); |
| safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& operator=(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& src); |
| safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(); |
| ~safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* src); |
| VkPhysicalDeviceFragmentDensityMapPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(this); } |
| VkPhysicalDeviceFragmentDensityMapPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkRenderPassFragmentDensityMapCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkAttachmentReference fragmentDensityMapAttachment; |
| safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct); |
| safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& src); |
| safe_VkRenderPassFragmentDensityMapCreateInfoEXT& operator=(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& src); |
| safe_VkRenderPassFragmentDensityMapCreateInfoEXT(); |
| ~safe_VkRenderPassFragmentDensityMapCreateInfoEXT(); |
| void initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct); |
| void initialize(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT* src); |
| VkRenderPassFragmentDensityMapCreateInfoEXT *ptr() { return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT *>(this); } |
| VkRenderPassFragmentDensityMapCreateInfoEXT const *ptr() const { return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 scalarBlockLayout; |
| safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT(const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT(const safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT& src); |
| safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=(const safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT& src); |
| safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT(); |
| ~safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* src); |
| VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *>(this); } |
| VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 subgroupSizeControl; |
| VkBool32 computeFullSubgroups; |
| safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& src); |
| safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& src); |
| safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(); |
| ~safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* src); |
| VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>(this); } |
| VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t minSubgroupSize; |
| uint32_t maxSubgroupSize; |
| uint32_t maxComputeWorkgroupSubgroups; |
| VkShaderStageFlags requiredSubgroupSizeStages; |
| safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& src); |
| safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& src); |
| safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(); |
| ~safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* src); |
| VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>(this); } |
| VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t requiredSubgroupSize; |
| safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct); |
| safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& src); |
| safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& src); |
| safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(); |
| ~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(); |
| void initialize(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* src); |
| VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>(this); } |
| VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderCoreProperties2AMD { |
| VkStructureType sType; |
| void* pNext; |
| VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; |
| uint32_t activeComputeUnitCount; |
| safe_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct); |
| safe_VkPhysicalDeviceShaderCoreProperties2AMD(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& src); |
| safe_VkPhysicalDeviceShaderCoreProperties2AMD& operator=(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& src); |
| safe_VkPhysicalDeviceShaderCoreProperties2AMD(); |
| ~safe_VkPhysicalDeviceShaderCoreProperties2AMD(); |
| void initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* src); |
| VkPhysicalDeviceShaderCoreProperties2AMD *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD *>(this); } |
| VkPhysicalDeviceShaderCoreProperties2AMD const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 deviceCoherentMemory; |
| safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct); |
| safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& src); |
| safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& operator=(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& src); |
| safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(); |
| ~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(); |
| void initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct); |
| void initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* src); |
| VkPhysicalDeviceCoherentMemoryFeaturesAMD *ptr() { return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(this); } |
| VkPhysicalDeviceCoherentMemoryFeaturesAMD const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; |
| VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; |
| safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& src); |
| safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& operator=(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& src); |
| safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(); |
| ~safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT* src); |
| VkPhysicalDeviceMemoryBudgetPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(this); } |
| VkPhysicalDeviceMemoryBudgetPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 memoryPriority; |
| safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& src); |
| safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& operator=(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& src); |
| safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(); |
| ~safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT* src); |
| VkPhysicalDeviceMemoryPriorityFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(this); } |
| VkPhysicalDeviceMemoryPriorityFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkMemoryPriorityAllocateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| float priority; |
| safe_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct); |
| safe_VkMemoryPriorityAllocateInfoEXT(const safe_VkMemoryPriorityAllocateInfoEXT& src); |
| safe_VkMemoryPriorityAllocateInfoEXT& operator=(const safe_VkMemoryPriorityAllocateInfoEXT& src); |
| safe_VkMemoryPriorityAllocateInfoEXT(); |
| ~safe_VkMemoryPriorityAllocateInfoEXT(); |
| void initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct); |
| void initialize(const safe_VkMemoryPriorityAllocateInfoEXT* src); |
| VkMemoryPriorityAllocateInfoEXT *ptr() { return reinterpret_cast<VkMemoryPriorityAllocateInfoEXT *>(this); } |
| VkMemoryPriorityAllocateInfoEXT const *ptr() const { return reinterpret_cast<VkMemoryPriorityAllocateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 dedicatedAllocationImageAliasing; |
| safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& src); |
| safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& src); |
| safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(); |
| ~safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(); |
| void initialize(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* src); |
| VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(this); } |
| VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 bufferDeviceAddress; |
| VkBool32 bufferDeviceAddressCaptureReplay; |
| VkBool32 bufferDeviceAddressMultiDevice; |
| safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& src); |
| safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& src); |
| safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(); |
| ~safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* src); |
| VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(this); } |
| VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkBufferDeviceAddressInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkBuffer buffer; |
| safe_VkBufferDeviceAddressInfoEXT(const VkBufferDeviceAddressInfoEXT* in_struct); |
| safe_VkBufferDeviceAddressInfoEXT(const safe_VkBufferDeviceAddressInfoEXT& src); |
| safe_VkBufferDeviceAddressInfoEXT& operator=(const safe_VkBufferDeviceAddressInfoEXT& src); |
| safe_VkBufferDeviceAddressInfoEXT(); |
| ~safe_VkBufferDeviceAddressInfoEXT(); |
| void initialize(const VkBufferDeviceAddressInfoEXT* in_struct); |
| void initialize(const safe_VkBufferDeviceAddressInfoEXT* src); |
| VkBufferDeviceAddressInfoEXT *ptr() { return reinterpret_cast<VkBufferDeviceAddressInfoEXT *>(this); } |
| VkBufferDeviceAddressInfoEXT const *ptr() const { return reinterpret_cast<VkBufferDeviceAddressInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkBufferDeviceAddressCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkDeviceAddress deviceAddress; |
| safe_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT* in_struct); |
| safe_VkBufferDeviceAddressCreateInfoEXT(const safe_VkBufferDeviceAddressCreateInfoEXT& src); |
| safe_VkBufferDeviceAddressCreateInfoEXT& operator=(const safe_VkBufferDeviceAddressCreateInfoEXT& src); |
| safe_VkBufferDeviceAddressCreateInfoEXT(); |
| ~safe_VkBufferDeviceAddressCreateInfoEXT(); |
| void initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct); |
| void initialize(const safe_VkBufferDeviceAddressCreateInfoEXT* src); |
| VkBufferDeviceAddressCreateInfoEXT *ptr() { return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT *>(this); } |
| VkBufferDeviceAddressCreateInfoEXT const *ptr() const { return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkImageStencilUsageCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkImageUsageFlags stencilUsage; |
| safe_VkImageStencilUsageCreateInfoEXT(const VkImageStencilUsageCreateInfoEXT* in_struct); |
| safe_VkImageStencilUsageCreateInfoEXT(const safe_VkImageStencilUsageCreateInfoEXT& src); |
| safe_VkImageStencilUsageCreateInfoEXT& operator=(const safe_VkImageStencilUsageCreateInfoEXT& src); |
| safe_VkImageStencilUsageCreateInfoEXT(); |
| ~safe_VkImageStencilUsageCreateInfoEXT(); |
| void initialize(const VkImageStencilUsageCreateInfoEXT* in_struct); |
| void initialize(const safe_VkImageStencilUsageCreateInfoEXT* src); |
| VkImageStencilUsageCreateInfoEXT *ptr() { return reinterpret_cast<VkImageStencilUsageCreateInfoEXT *>(this); } |
| VkImageStencilUsageCreateInfoEXT const *ptr() const { return reinterpret_cast<VkImageStencilUsageCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkValidationFeaturesEXT { |
| VkStructureType sType; |
| const void* pNext; |
| uint32_t enabledValidationFeatureCount; |
| const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; |
| uint32_t disabledValidationFeatureCount; |
| const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; |
| safe_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct); |
| safe_VkValidationFeaturesEXT(const safe_VkValidationFeaturesEXT& src); |
| safe_VkValidationFeaturesEXT& operator=(const safe_VkValidationFeaturesEXT& src); |
| safe_VkValidationFeaturesEXT(); |
| ~safe_VkValidationFeaturesEXT(); |
| void initialize(const VkValidationFeaturesEXT* in_struct); |
| void initialize(const safe_VkValidationFeaturesEXT* src); |
| VkValidationFeaturesEXT *ptr() { return reinterpret_cast<VkValidationFeaturesEXT *>(this); } |
| VkValidationFeaturesEXT const *ptr() const { return reinterpret_cast<VkValidationFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkCooperativeMatrixPropertiesNV { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t MSize; |
| uint32_t NSize; |
| uint32_t KSize; |
| VkComponentTypeNV AType; |
| VkComponentTypeNV BType; |
| VkComponentTypeNV CType; |
| VkComponentTypeNV DType; |
| VkScopeNV scope; |
| safe_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* in_struct); |
| safe_VkCooperativeMatrixPropertiesNV(const safe_VkCooperativeMatrixPropertiesNV& src); |
| safe_VkCooperativeMatrixPropertiesNV& operator=(const safe_VkCooperativeMatrixPropertiesNV& src); |
| safe_VkCooperativeMatrixPropertiesNV(); |
| ~safe_VkCooperativeMatrixPropertiesNV(); |
| void initialize(const VkCooperativeMatrixPropertiesNV* in_struct); |
| void initialize(const safe_VkCooperativeMatrixPropertiesNV* src); |
| VkCooperativeMatrixPropertiesNV *ptr() { return reinterpret_cast<VkCooperativeMatrixPropertiesNV *>(this); } |
| VkCooperativeMatrixPropertiesNV const *ptr() const { return reinterpret_cast<VkCooperativeMatrixPropertiesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 cooperativeMatrix; |
| VkBool32 cooperativeMatrixRobustBufferAccess; |
| safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& src); |
| safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& src); |
| safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(); |
| ~safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(); |
| void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV* src); |
| VkPhysicalDeviceCooperativeMatrixFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(this); } |
| VkPhysicalDeviceCooperativeMatrixFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkShaderStageFlags cooperativeMatrixSupportedStages; |
| safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct); |
| safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& src); |
| safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& operator=(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& src); |
| safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(); |
| ~safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(); |
| void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV* src); |
| VkPhysicalDeviceCooperativeMatrixPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(this); } |
| VkPhysicalDeviceCooperativeMatrixPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 coverageReductionMode; |
| safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct); |
| safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& src); |
| safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& operator=(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& src); |
| safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(); |
| ~safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(); |
| void initialize(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct); |
| void initialize(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV* src); |
| VkPhysicalDeviceCoverageReductionModeFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(this); } |
| VkPhysicalDeviceCoverageReductionModeFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV const *>(this); } |
| }; |
| |
| struct safe_VkPipelineCoverageReductionStateCreateInfoNV { |
| VkStructureType sType; |
| const void* pNext; |
| VkPipelineCoverageReductionStateCreateFlagsNV flags; |
| VkCoverageReductionModeNV coverageReductionMode; |
| safe_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct); |
| safe_VkPipelineCoverageReductionStateCreateInfoNV(const safe_VkPipelineCoverageReductionStateCreateInfoNV& src); |
| safe_VkPipelineCoverageReductionStateCreateInfoNV& operator=(const safe_VkPipelineCoverageReductionStateCreateInfoNV& src); |
| safe_VkPipelineCoverageReductionStateCreateInfoNV(); |
| ~safe_VkPipelineCoverageReductionStateCreateInfoNV(); |
| void initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct); |
| void initialize(const safe_VkPipelineCoverageReductionStateCreateInfoNV* src); |
| VkPipelineCoverageReductionStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV *>(this); } |
| VkPipelineCoverageReductionStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV const *>(this); } |
| }; |
| |
| struct safe_VkFramebufferMixedSamplesCombinationNV { |
| VkStructureType sType; |
| void* pNext; |
| VkCoverageReductionModeNV coverageReductionMode; |
| VkSampleCountFlagBits rasterizationSamples; |
| VkSampleCountFlags depthStencilSamples; |
| VkSampleCountFlags colorSamples; |
| safe_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV* in_struct); |
| safe_VkFramebufferMixedSamplesCombinationNV(const safe_VkFramebufferMixedSamplesCombinationNV& src); |
| safe_VkFramebufferMixedSamplesCombinationNV& operator=(const safe_VkFramebufferMixedSamplesCombinationNV& src); |
| safe_VkFramebufferMixedSamplesCombinationNV(); |
| ~safe_VkFramebufferMixedSamplesCombinationNV(); |
| void initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct); |
| void initialize(const safe_VkFramebufferMixedSamplesCombinationNV* src); |
| VkFramebufferMixedSamplesCombinationNV *ptr() { return reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>(this); } |
| VkFramebufferMixedSamplesCombinationNV const *ptr() const { return reinterpret_cast<VkFramebufferMixedSamplesCombinationNV const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 fragmentShaderSampleInterlock; |
| VkBool32 fragmentShaderPixelInterlock; |
| VkBool32 fragmentShaderShadingRateInterlock; |
| safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& src); |
| safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& src); |
| safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(); |
| ~safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* src); |
| VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(this); } |
| VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 ycbcrImageArrays; |
| safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& src); |
| safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& src); |
| safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(); |
| ~safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* src); |
| VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(this); } |
| VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const *>(this); } |
| }; |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkSurfaceFullScreenExclusiveInfoEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkFullScreenExclusiveEXT fullScreenExclusive; |
| safe_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct); |
| safe_VkSurfaceFullScreenExclusiveInfoEXT(const safe_VkSurfaceFullScreenExclusiveInfoEXT& src); |
| safe_VkSurfaceFullScreenExclusiveInfoEXT& operator=(const safe_VkSurfaceFullScreenExclusiveInfoEXT& src); |
| safe_VkSurfaceFullScreenExclusiveInfoEXT(); |
| ~safe_VkSurfaceFullScreenExclusiveInfoEXT(); |
| void initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct); |
| void initialize(const safe_VkSurfaceFullScreenExclusiveInfoEXT* src); |
| VkSurfaceFullScreenExclusiveInfoEXT *ptr() { return reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT *>(this); } |
| VkSurfaceFullScreenExclusiveInfoEXT const *ptr() const { return reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 fullScreenExclusiveSupported; |
| safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct); |
| safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& src); |
| safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& operator=(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& src); |
| safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(); |
| ~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(); |
| void initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct); |
| void initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* src); |
| VkSurfaceCapabilitiesFullScreenExclusiveEXT *ptr() { return reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(this); } |
| VkSurfaceCapabilitiesFullScreenExclusiveEXT const *ptr() const { return reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| struct safe_VkSurfaceFullScreenExclusiveWin32InfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| HMONITOR hmonitor; |
| safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct); |
| safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& src); |
| safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& operator=(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& src); |
| safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(); |
| ~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(); |
| void initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct); |
| void initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* src); |
| VkSurfaceFullScreenExclusiveWin32InfoEXT *ptr() { return reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT *>(this); } |
| VkSurfaceFullScreenExclusiveWin32InfoEXT const *ptr() const { return reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT const *>(this); } |
| }; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| struct safe_VkHeadlessSurfaceCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkHeadlessSurfaceCreateFlagsEXT flags; |
| safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct); |
| safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& src); |
| safe_VkHeadlessSurfaceCreateInfoEXT& operator=(const safe_VkHeadlessSurfaceCreateInfoEXT& src); |
| safe_VkHeadlessSurfaceCreateInfoEXT(); |
| ~safe_VkHeadlessSurfaceCreateInfoEXT(); |
| void initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct); |
| void initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* src); |
| VkHeadlessSurfaceCreateInfoEXT *ptr() { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT *>(this); } |
| VkHeadlessSurfaceCreateInfoEXT const *ptr() const { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceLineRasterizationFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 rectangularLines; |
| VkBool32 bresenhamLines; |
| VkBool32 smoothLines; |
| VkBool32 stippledRectangularLines; |
| VkBool32 stippledBresenhamLines; |
| VkBool32 stippledSmoothLines; |
| safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& src); |
| safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& src); |
| safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(); |
| ~safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT* src); |
| VkPhysicalDeviceLineRasterizationFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>(this); } |
| VkPhysicalDeviceLineRasterizationFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceLineRasterizationPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| uint32_t lineSubPixelPrecisionBits; |
| safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& src); |
| safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& operator=(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& src); |
| safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(); |
| ~safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT* src); |
| VkPhysicalDeviceLineRasterizationPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT *>(this); } |
| VkPhysicalDeviceLineRasterizationPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPipelineRasterizationLineStateCreateInfoEXT { |
| VkStructureType sType; |
| const void* pNext; |
| VkLineRasterizationModeEXT lineRasterizationMode; |
| VkBool32 stippledLineEnable; |
| uint32_t lineStippleFactor; |
| uint16_t lineStipplePattern; |
| safe_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct); |
| safe_VkPipelineRasterizationLineStateCreateInfoEXT(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& src); |
| safe_VkPipelineRasterizationLineStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& src); |
| safe_VkPipelineRasterizationLineStateCreateInfoEXT(); |
| ~safe_VkPipelineRasterizationLineStateCreateInfoEXT(); |
| void initialize(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct); |
| void initialize(const safe_VkPipelineRasterizationLineStateCreateInfoEXT* src); |
| VkPipelineRasterizationLineStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT *>(this); } |
| VkPipelineRasterizationLineStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceHostQueryResetFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 hostQueryReset; |
| safe_VkPhysicalDeviceHostQueryResetFeaturesEXT(const VkPhysicalDeviceHostQueryResetFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceHostQueryResetFeaturesEXT(const safe_VkPhysicalDeviceHostQueryResetFeaturesEXT& src); |
| safe_VkPhysicalDeviceHostQueryResetFeaturesEXT& operator=(const safe_VkPhysicalDeviceHostQueryResetFeaturesEXT& src); |
| safe_VkPhysicalDeviceHostQueryResetFeaturesEXT(); |
| ~safe_VkPhysicalDeviceHostQueryResetFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceHostQueryResetFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceHostQueryResetFeaturesEXT* src); |
| VkPhysicalDeviceHostQueryResetFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT *>(this); } |
| VkPhysicalDeviceHostQueryResetFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 indexTypeUint8; |
| safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& src); |
| safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& src); |
| safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(); |
| ~safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(); |
| void initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT* src); |
| VkPhysicalDeviceIndexTypeUint8FeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(this); } |
| VkPhysicalDeviceIndexTypeUint8FeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 shaderDemoteToHelperInvocation; |
| safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& src); |
| safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& src); |
| safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(); |
| ~safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* src); |
| VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>(this); } |
| VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkBool32 texelBufferAlignment; |
| safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct); |
| safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& src); |
| safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& src); |
| safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(); |
| ~safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(); |
| void initialize(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* src); |
| VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(this); } |
| VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const *>(this); } |
| }; |
| |
| struct safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT { |
| VkStructureType sType; |
| void* pNext; |
| VkDeviceSize storageTexelBufferOffsetAlignmentBytes; |
| VkBool32 storageTexelBufferOffsetSingleTexelAlignment; |
| VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; |
| VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; |
| safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* in_struct); |
| safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& src); |
| safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& src); |
| safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(); |
| ~safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(); |
| void initialize(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* in_struct); |
| void initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* src); |
| VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>(this); } |
| VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const *>(this); } |
| }; |